nn/runtime/test/generated/all_generated_V1_2_vts_tests.cpp

// clang-format off
// DO NOT EDIT;
// Generated by ml/nn/runtime/test/specs/generate_vts_test.sh
// Generated from: abs.mod.py.
namespace abs {
// Generated abs test
#include "examples/abs.example.cpp"
// Generated model constructor
#include "vts_models/abs.model.cpp"
} // namespace abs

TEST_F(NeuralnetworksHidlTest, abs) {
  generated_tests::Execute(device,
                           abs::createTestModel,
                           abs::is_ignored,
                           abs::get_examples());
}

TEST_F(ValidationTest, abs) {
  const Model model = abs::createTestModel();
  const std::vector<Request> requests = createRequests(abs::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, abs_relaxed) {
  generated_tests::Execute(device,
                           abs::createTestModel_relaxed,
                           abs::is_ignored_relaxed,
                           abs::get_examples_relaxed());
}

TEST_F(ValidationTest, abs_relaxed) {
  const Model model = abs::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(abs::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, abs_float16) {
  generated_tests::Execute(device,
                           abs::createTestModel_float16,
                           abs::is_ignored_float16,
                           abs::get_examples_float16());
}

TEST_F(ValidationTest, abs_float16) {
  const Model model = abs::createTestModel_float16();
  const std::vector<Request> requests = createRequests(abs::get_examples_float16());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: add_broadcast_float16.mod.py.
namespace add_broadcast_float16 {
// Generated add_broadcast_float16 test
#include "examples/add_broadcast_float16.example.cpp"
// Generated model constructor
#include "vts_models/add_broadcast_float16.model.cpp"
} // namespace add_broadcast_float16

TEST_F(NeuralnetworksHidlTest, add_broadcast_float16) {
  generated_tests::Execute(device,
                           add_broadcast_float16::createTestModel,
                           add_broadcast_float16::is_ignored,
                           add_broadcast_float16::get_examples());
}

TEST_F(ValidationTest, add_broadcast_float16) {
  const Model model = add_broadcast_float16::createTestModel();
  const std::vector<Request> requests = createRequests(add_broadcast_float16::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: add_float16.mod.py.
namespace add_float16 {
// Generated add_float16 test
#include "examples/add_float16.example.cpp"
// Generated model constructor
#include "vts_models/add_float16.model.cpp"
} // namespace add_float16

TEST_F(NeuralnetworksHidlTest, add_float16) {
  generated_tests::Execute(device,
                           add_float16::createTestModel,
                           add_float16::is_ignored,
                           add_float16::get_examples());
}

TEST_F(ValidationTest, add_float16) {
  const Model model = add_float16::createTestModel();
  const std::vector<Request> requests = createRequests(add_float16::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: argmax_1.mod.py.
namespace argmax_1 {
// Generated argmax_1 test
#include "examples/argmax_1.example.cpp"
// Generated model constructor
#include "vts_models/argmax_1.model.cpp"
} // namespace argmax_1

TEST_F(NeuralnetworksHidlTest, argmax_1) {
  generated_tests::Execute(device,
                           argmax_1::createTestModel,
                           argmax_1::is_ignored,
                           argmax_1::get_examples());
}

TEST_F(ValidationTest, argmax_1) {
  const Model model = argmax_1::createTestModel();
  const std::vector<Request> requests = createRequests(argmax_1::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmax_1_relaxed) {
  generated_tests::Execute(device,
                           argmax_1::createTestModel_relaxed,
                           argmax_1::is_ignored_relaxed,
                           argmax_1::get_examples_relaxed());
}

TEST_F(ValidationTest, argmax_1_relaxed) {
  const Model model = argmax_1::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(argmax_1::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmax_1_float16) {
  generated_tests::Execute(device,
                           argmax_1::createTestModel_float16,
                           argmax_1::is_ignored_float16,
                           argmax_1::get_examples_float16());
}

TEST_F(ValidationTest, argmax_1_float16) {
  const Model model = argmax_1::createTestModel_float16();
  const std::vector<Request> requests = createRequests(argmax_1::get_examples_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmax_1_int32) {
  generated_tests::Execute(device,
                           argmax_1::createTestModel_int32,
                           argmax_1::is_ignored_int32,
                           argmax_1::get_examples_int32());
}

TEST_F(ValidationTest, argmax_1_int32) {
  const Model model = argmax_1::createTestModel_int32();
  const std::vector<Request> requests = createRequests(argmax_1::get_examples_int32());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmax_1_quant8) {
  generated_tests::Execute(device,
                           argmax_1::createTestModel_quant8,
                           argmax_1::is_ignored_quant8,
                           argmax_1::get_examples_quant8());
}

TEST_F(ValidationTest, argmax_1_quant8) {
  const Model model = argmax_1::createTestModel_quant8();
  const std::vector<Request> requests = createRequests(argmax_1::get_examples_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: argmax_2.mod.py.
namespace argmax_2 {
// Generated argmax_2 test
#include "examples/argmax_2.example.cpp"
// Generated model constructor
#include "vts_models/argmax_2.model.cpp"
} // namespace argmax_2

TEST_F(NeuralnetworksHidlTest, argmax_2) {
  generated_tests::Execute(device,
                           argmax_2::createTestModel,
                           argmax_2::is_ignored,
                           argmax_2::get_examples());
}

TEST_F(ValidationTest, argmax_2) {
  const Model model = argmax_2::createTestModel();
  const std::vector<Request> requests = createRequests(argmax_2::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmax_2_relaxed) {
  generated_tests::Execute(device,
                           argmax_2::createTestModel_relaxed,
                           argmax_2::is_ignored_relaxed,
                           argmax_2::get_examples_relaxed());
}

TEST_F(ValidationTest, argmax_2_relaxed) {
  const Model model = argmax_2::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(argmax_2::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmax_2_float16) {
  generated_tests::Execute(device,
                           argmax_2::createTestModel_float16,
                           argmax_2::is_ignored_float16,
                           argmax_2::get_examples_float16());
}

TEST_F(ValidationTest, argmax_2_float16) {
  const Model model = argmax_2::createTestModel_float16();
  const std::vector<Request> requests = createRequests(argmax_2::get_examples_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmax_2_int32) {
  generated_tests::Execute(device,
                           argmax_2::createTestModel_int32,
                           argmax_2::is_ignored_int32,
                           argmax_2::get_examples_int32());
}

TEST_F(ValidationTest, argmax_2_int32) {
  const Model model = argmax_2::createTestModel_int32();
  const std::vector<Request> requests = createRequests(argmax_2::get_examples_int32());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmax_2_quant8) {
  generated_tests::Execute(device,
                           argmax_2::createTestModel_quant8,
                           argmax_2::is_ignored_quant8,
                           argmax_2::get_examples_quant8());
}

TEST_F(ValidationTest, argmax_2_quant8) {
  const Model model = argmax_2::createTestModel_quant8();
  const std::vector<Request> requests = createRequests(argmax_2::get_examples_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: argmax_3.mod.py.
namespace argmax_3 {
// Generated argmax_3 test
#include "examples/argmax_3.example.cpp"
// Generated model constructor
#include "vts_models/argmax_3.model.cpp"
} // namespace argmax_3

TEST_F(NeuralnetworksHidlTest, argmax_3) {
  generated_tests::Execute(device,
                           argmax_3::createTestModel,
                           argmax_3::is_ignored,
                           argmax_3::get_examples());
}

TEST_F(ValidationTest, argmax_3) {
  const Model model = argmax_3::createTestModel();
  const std::vector<Request> requests = createRequests(argmax_3::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmax_3_relaxed) {
  generated_tests::Execute(device,
                           argmax_3::createTestModel_relaxed,
                           argmax_3::is_ignored_relaxed,
                           argmax_3::get_examples_relaxed());
}

TEST_F(ValidationTest, argmax_3_relaxed) {
  const Model model = argmax_3::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(argmax_3::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmax_3_float16) {
  generated_tests::Execute(device,
                           argmax_3::createTestModel_float16,
                           argmax_3::is_ignored_float16,
                           argmax_3::get_examples_float16());
}

TEST_F(ValidationTest, argmax_3_float16) {
  const Model model = argmax_3::createTestModel_float16();
  const std::vector<Request> requests = createRequests(argmax_3::get_examples_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmax_3_int32) {
  generated_tests::Execute(device,
                           argmax_3::createTestModel_int32,
                           argmax_3::is_ignored_int32,
                           argmax_3::get_examples_int32());
}

TEST_F(ValidationTest, argmax_3_int32) {
  const Model model = argmax_3::createTestModel_int32();
  const std::vector<Request> requests = createRequests(argmax_3::get_examples_int32());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmax_3_quant8) {
  generated_tests::Execute(device,
                           argmax_3::createTestModel_quant8,
                           argmax_3::is_ignored_quant8,
                           argmax_3::get_examples_quant8());
}

TEST_F(ValidationTest, argmax_3_quant8) {
  const Model model = argmax_3::createTestModel_quant8();
  const std::vector<Request> requests = createRequests(argmax_3::get_examples_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: argmin_1.mod.py.
namespace argmin_1 {
// Generated argmin_1 test
#include "examples/argmin_1.example.cpp"
// Generated model constructor
#include "vts_models/argmin_1.model.cpp"
} // namespace argmin_1

TEST_F(NeuralnetworksHidlTest, argmin_1) {
  generated_tests::Execute(device,
                           argmin_1::createTestModel,
                           argmin_1::is_ignored,
                           argmin_1::get_examples());
}

TEST_F(ValidationTest, argmin_1) {
  const Model model = argmin_1::createTestModel();
  const std::vector<Request> requests = createRequests(argmin_1::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmin_1_relaxed) {
  generated_tests::Execute(device,
                           argmin_1::createTestModel_relaxed,
                           argmin_1::is_ignored_relaxed,
                           argmin_1::get_examples_relaxed());
}

TEST_F(ValidationTest, argmin_1_relaxed) {
  const Model model = argmin_1::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(argmin_1::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmin_1_float16) {
  generated_tests::Execute(device,
                           argmin_1::createTestModel_float16,
                           argmin_1::is_ignored_float16,
                           argmin_1::get_examples_float16());
}

TEST_F(ValidationTest, argmin_1_float16) {
  const Model model = argmin_1::createTestModel_float16();
  const std::vector<Request> requests = createRequests(argmin_1::get_examples_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmin_1_int32) {
  generated_tests::Execute(device,
                           argmin_1::createTestModel_int32,
                           argmin_1::is_ignored_int32,
                           argmin_1::get_examples_int32());
}

TEST_F(ValidationTest, argmin_1_int32) {
  const Model model = argmin_1::createTestModel_int32();
  const std::vector<Request> requests = createRequests(argmin_1::get_examples_int32());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmin_1_quant8) {
  generated_tests::Execute(device,
                           argmin_1::createTestModel_quant8,
                           argmin_1::is_ignored_quant8,
                           argmin_1::get_examples_quant8());
}

TEST_F(ValidationTest, argmin_1_quant8) {
  const Model model = argmin_1::createTestModel_quant8();
  const std::vector<Request> requests = createRequests(argmin_1::get_examples_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: argmin_2.mod.py.
namespace argmin_2 {
// Generated argmin_2 test
#include "examples/argmin_2.example.cpp"
// Generated model constructor
#include "vts_models/argmin_2.model.cpp"
} // namespace argmin_2

TEST_F(NeuralnetworksHidlTest, argmin_2) {
  generated_tests::Execute(device,
                           argmin_2::createTestModel,
                           argmin_2::is_ignored,
                           argmin_2::get_examples());
}

TEST_F(ValidationTest, argmin_2) {
  const Model model = argmin_2::createTestModel();
  const std::vector<Request> requests = createRequests(argmin_2::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmin_2_relaxed) {
  generated_tests::Execute(device,
                           argmin_2::createTestModel_relaxed,
                           argmin_2::is_ignored_relaxed,
                           argmin_2::get_examples_relaxed());
}

TEST_F(ValidationTest, argmin_2_relaxed) {
  const Model model = argmin_2::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(argmin_2::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmin_2_float16) {
  generated_tests::Execute(device,
                           argmin_2::createTestModel_float16,
                           argmin_2::is_ignored_float16,
                           argmin_2::get_examples_float16());
}

TEST_F(ValidationTest, argmin_2_float16) {
  const Model model = argmin_2::createTestModel_float16();
  const std::vector<Request> requests = createRequests(argmin_2::get_examples_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmin_2_int32) {
  generated_tests::Execute(device,
                           argmin_2::createTestModel_int32,
                           argmin_2::is_ignored_int32,
                           argmin_2::get_examples_int32());
}

TEST_F(ValidationTest, argmin_2_int32) {
  const Model model = argmin_2::createTestModel_int32();
  const std::vector<Request> requests = createRequests(argmin_2::get_examples_int32());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmin_2_quant8) {
  generated_tests::Execute(device,
                           argmin_2::createTestModel_quant8,
                           argmin_2::is_ignored_quant8,
                           argmin_2::get_examples_quant8());
}

TEST_F(ValidationTest, argmin_2_quant8) {
  const Model model = argmin_2::createTestModel_quant8();
  const std::vector<Request> requests = createRequests(argmin_2::get_examples_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: argmin_3.mod.py.
namespace argmin_3 {
// Generated argmin_3 test
#include "examples/argmin_3.example.cpp"
// Generated model constructor
#include "vts_models/argmin_3.model.cpp"
} // namespace argmin_3

TEST_F(NeuralnetworksHidlTest, argmin_3) {
  generated_tests::Execute(device,
                           argmin_3::createTestModel,
                           argmin_3::is_ignored,
                           argmin_3::get_examples());
}

TEST_F(ValidationTest, argmin_3) {
  const Model model = argmin_3::createTestModel();
  const std::vector<Request> requests = createRequests(argmin_3::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmin_3_relaxed) {
  generated_tests::Execute(device,
                           argmin_3::createTestModel_relaxed,
                           argmin_3::is_ignored_relaxed,
                           argmin_3::get_examples_relaxed());
}

TEST_F(ValidationTest, argmin_3_relaxed) {
  const Model model = argmin_3::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(argmin_3::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmin_3_float16) {
  generated_tests::Execute(device,
                           argmin_3::createTestModel_float16,
                           argmin_3::is_ignored_float16,
                           argmin_3::get_examples_float16());
}

TEST_F(ValidationTest, argmin_3_float16) {
  const Model model = argmin_3::createTestModel_float16();
  const std::vector<Request> requests = createRequests(argmin_3::get_examples_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmin_3_int32) {
  generated_tests::Execute(device,
                           argmin_3::createTestModel_int32,
                           argmin_3::is_ignored_int32,
                           argmin_3::get_examples_int32());
}

TEST_F(ValidationTest, argmin_3_int32) {
  const Model model = argmin_3::createTestModel_int32();
  const std::vector<Request> requests = createRequests(argmin_3::get_examples_int32());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, argmin_3_quant8) {
  generated_tests::Execute(device,
                           argmin_3::createTestModel_quant8,
                           argmin_3::is_ignored_quant8,
                           argmin_3::get_examples_quant8());
}

TEST_F(ValidationTest, argmin_3_quant8) {
  const Model model = argmin_3::createTestModel_quant8();
  const std::vector<Request> requests = createRequests(argmin_3::get_examples_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: avg_pool_v1_2.mod.py.
namespace avg_pool_v1_2 {
// Generated avg_pool_v1_2 test
#include "examples/avg_pool_v1_2.example.cpp"
// Generated model constructor
#include "vts_models/avg_pool_v1_2.model.cpp"
} // namespace avg_pool_v1_2

TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nhwc) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nhwc,
                           avg_pool_v1_2::is_ignored_nhwc,
                           avg_pool_v1_2::get_examples_nhwc());
}

TEST_F(ValidationTest, avg_pool_v1_2_nhwc) {
  const Model model = avg_pool_v1_2::createTestModel_nhwc();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nhwc());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nhwc_relaxed) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nhwc_relaxed,
                           avg_pool_v1_2::is_ignored_nhwc_relaxed,
                           avg_pool_v1_2::get_examples_nhwc_relaxed());
}

TEST_F(ValidationTest, avg_pool_v1_2_nhwc_relaxed) {
  const Model model = avg_pool_v1_2::createTestModel_nhwc_relaxed();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nhwc_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nhwc_quant8) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nhwc_quant8,
                           avg_pool_v1_2::is_ignored_nhwc_quant8,
                           avg_pool_v1_2::get_examples_nhwc_quant8());
}

TEST_F(ValidationTest, avg_pool_v1_2_nhwc_quant8) {
  const Model model = avg_pool_v1_2::createTestModel_nhwc_quant8();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nhwc_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nchw) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nchw,
                           avg_pool_v1_2::is_ignored_nchw,
                           avg_pool_v1_2::get_examples_nchw());
}

TEST_F(ValidationTest, avg_pool_v1_2_nchw) {
  const Model model = avg_pool_v1_2::createTestModel_nchw();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nchw());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nchw_relaxed) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nchw_relaxed,
                           avg_pool_v1_2::is_ignored_nchw_relaxed,
                           avg_pool_v1_2::get_examples_nchw_relaxed());
}

TEST_F(ValidationTest, avg_pool_v1_2_nchw_relaxed) {
  const Model model = avg_pool_v1_2::createTestModel_nchw_relaxed();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nchw_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nchw_quant8) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nchw_quant8,
                           avg_pool_v1_2::is_ignored_nchw_quant8,
                           avg_pool_v1_2::get_examples_nchw_quant8());
}

TEST_F(ValidationTest, avg_pool_v1_2_nchw_quant8) {
  const Model model = avg_pool_v1_2::createTestModel_nchw_quant8();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nchw_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nhwc_2) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nhwc_2,
                           avg_pool_v1_2::is_ignored_nhwc_2,
                           avg_pool_v1_2::get_examples_nhwc_2());
}

TEST_F(ValidationTest, avg_pool_v1_2_nhwc_2) {
  const Model model = avg_pool_v1_2::createTestModel_nhwc_2();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nhwc_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nhwc_relaxed_2) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nhwc_relaxed_2,
                           avg_pool_v1_2::is_ignored_nhwc_relaxed_2,
                           avg_pool_v1_2::get_examples_nhwc_relaxed_2());
}

TEST_F(ValidationTest, avg_pool_v1_2_nhwc_relaxed_2) {
  const Model model = avg_pool_v1_2::createTestModel_nhwc_relaxed_2();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nhwc_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nhwc_quant8_2) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nhwc_quant8_2,
                           avg_pool_v1_2::is_ignored_nhwc_quant8_2,
                           avg_pool_v1_2::get_examples_nhwc_quant8_2());
}

TEST_F(ValidationTest, avg_pool_v1_2_nhwc_quant8_2) {
  const Model model = avg_pool_v1_2::createTestModel_nhwc_quant8_2();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nhwc_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nchw_2) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nchw_2,
                           avg_pool_v1_2::is_ignored_nchw_2,
                           avg_pool_v1_2::get_examples_nchw_2());
}

TEST_F(ValidationTest, avg_pool_v1_2_nchw_2) {
  const Model model = avg_pool_v1_2::createTestModel_nchw_2();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nchw_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nchw_relaxed_2) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nchw_relaxed_2,
                           avg_pool_v1_2::is_ignored_nchw_relaxed_2,
                           avg_pool_v1_2::get_examples_nchw_relaxed_2());
}

TEST_F(ValidationTest, avg_pool_v1_2_nchw_relaxed_2) {
  const Model model = avg_pool_v1_2::createTestModel_nchw_relaxed_2();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nchw_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nchw_quant8_2) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nchw_quant8_2,
                           avg_pool_v1_2::is_ignored_nchw_quant8_2,
                           avg_pool_v1_2::get_examples_nchw_quant8_2());
}

TEST_F(ValidationTest, avg_pool_v1_2_nchw_quant8_2) {
  const Model model = avg_pool_v1_2::createTestModel_nchw_quant8_2();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nchw_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nhwc_3) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nhwc_3,
                           avg_pool_v1_2::is_ignored_nhwc_3,
                           avg_pool_v1_2::get_examples_nhwc_3());
}

TEST_F(ValidationTest, avg_pool_v1_2_nhwc_3) {
  const Model model = avg_pool_v1_2::createTestModel_nhwc_3();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nhwc_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nhwc_relaxed_3) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nhwc_relaxed_3,
                           avg_pool_v1_2::is_ignored_nhwc_relaxed_3,
                           avg_pool_v1_2::get_examples_nhwc_relaxed_3());
}

TEST_F(ValidationTest, avg_pool_v1_2_nhwc_relaxed_3) {
  const Model model = avg_pool_v1_2::createTestModel_nhwc_relaxed_3();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nhwc_relaxed_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nhwc_quant8_3) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nhwc_quant8_3,
                           avg_pool_v1_2::is_ignored_nhwc_quant8_3,
                           avg_pool_v1_2::get_examples_nhwc_quant8_3());
}

TEST_F(ValidationTest, avg_pool_v1_2_nhwc_quant8_3) {
  const Model model = avg_pool_v1_2::createTestModel_nhwc_quant8_3();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nhwc_quant8_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nchw_3) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nchw_3,
                           avg_pool_v1_2::is_ignored_nchw_3,
                           avg_pool_v1_2::get_examples_nchw_3());
}

TEST_F(ValidationTest, avg_pool_v1_2_nchw_3) {
  const Model model = avg_pool_v1_2::createTestModel_nchw_3();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nchw_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nchw_relaxed_3) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nchw_relaxed_3,
                           avg_pool_v1_2::is_ignored_nchw_relaxed_3,
                           avg_pool_v1_2::get_examples_nchw_relaxed_3());
}

TEST_F(ValidationTest, avg_pool_v1_2_nchw_relaxed_3) {
  const Model model = avg_pool_v1_2::createTestModel_nchw_relaxed_3();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nchw_relaxed_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nchw_quant8_3) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nchw_quant8_3,
                           avg_pool_v1_2::is_ignored_nchw_quant8_3,
                           avg_pool_v1_2::get_examples_nchw_quant8_3());
}

TEST_F(ValidationTest, avg_pool_v1_2_nchw_quant8_3) {
  const Model model = avg_pool_v1_2::createTestModel_nchw_quant8_3();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nchw_quant8_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nhwc_4) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nhwc_4,
                           avg_pool_v1_2::is_ignored_nhwc_4,
                           avg_pool_v1_2::get_examples_nhwc_4());
}

TEST_F(ValidationTest, avg_pool_v1_2_nhwc_4) {
  const Model model = avg_pool_v1_2::createTestModel_nhwc_4();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nhwc_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nhwc_relaxed_4) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nhwc_relaxed_4,
                           avg_pool_v1_2::is_ignored_nhwc_relaxed_4,
                           avg_pool_v1_2::get_examples_nhwc_relaxed_4());
}

TEST_F(ValidationTest, avg_pool_v1_2_nhwc_relaxed_4) {
  const Model model = avg_pool_v1_2::createTestModel_nhwc_relaxed_4();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nhwc_relaxed_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nhwc_quant8_4) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nhwc_quant8_4,
                           avg_pool_v1_2::is_ignored_nhwc_quant8_4,
                           avg_pool_v1_2::get_examples_nhwc_quant8_4());
}

TEST_F(ValidationTest, avg_pool_v1_2_nhwc_quant8_4) {
  const Model model = avg_pool_v1_2::createTestModel_nhwc_quant8_4();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nhwc_quant8_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nchw_4) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nchw_4,
                           avg_pool_v1_2::is_ignored_nchw_4,
                           avg_pool_v1_2::get_examples_nchw_4());
}

TEST_F(ValidationTest, avg_pool_v1_2_nchw_4) {
  const Model model = avg_pool_v1_2::createTestModel_nchw_4();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nchw_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nchw_relaxed_4) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nchw_relaxed_4,
                           avg_pool_v1_2::is_ignored_nchw_relaxed_4,
                           avg_pool_v1_2::get_examples_nchw_relaxed_4());
}

TEST_F(ValidationTest, avg_pool_v1_2_nchw_relaxed_4) {
  const Model model = avg_pool_v1_2::createTestModel_nchw_relaxed_4();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nchw_relaxed_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nchw_quant8_4) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nchw_quant8_4,
                           avg_pool_v1_2::is_ignored_nchw_quant8_4,
                           avg_pool_v1_2::get_examples_nchw_quant8_4());
}

TEST_F(ValidationTest, avg_pool_v1_2_nchw_quant8_4) {
  const Model model = avg_pool_v1_2::createTestModel_nchw_quant8_4();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nchw_quant8_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nhwc_5) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nhwc_5,
                           avg_pool_v1_2::is_ignored_nhwc_5,
                           avg_pool_v1_2::get_examples_nhwc_5());
}

TEST_F(ValidationTest, avg_pool_v1_2_nhwc_5) {
  const Model model = avg_pool_v1_2::createTestModel_nhwc_5();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nhwc_5());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nhwc_relaxed_5) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nhwc_relaxed_5,
                           avg_pool_v1_2::is_ignored_nhwc_relaxed_5,
                           avg_pool_v1_2::get_examples_nhwc_relaxed_5());
}

TEST_F(ValidationTest, avg_pool_v1_2_nhwc_relaxed_5) {
  const Model model = avg_pool_v1_2::createTestModel_nhwc_relaxed_5();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nhwc_relaxed_5());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nhwc_quant8_5) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nhwc_quant8_5,
                           avg_pool_v1_2::is_ignored_nhwc_quant8_5,
                           avg_pool_v1_2::get_examples_nhwc_quant8_5());
}

TEST_F(ValidationTest, avg_pool_v1_2_nhwc_quant8_5) {
  const Model model = avg_pool_v1_2::createTestModel_nhwc_quant8_5();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nhwc_quant8_5());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nchw_5) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nchw_5,
                           avg_pool_v1_2::is_ignored_nchw_5,
                           avg_pool_v1_2::get_examples_nchw_5());
}

TEST_F(ValidationTest, avg_pool_v1_2_nchw_5) {
  const Model model = avg_pool_v1_2::createTestModel_nchw_5();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nchw_5());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nchw_relaxed_5) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nchw_relaxed_5,
                           avg_pool_v1_2::is_ignored_nchw_relaxed_5,
                           avg_pool_v1_2::get_examples_nchw_relaxed_5());
}

TEST_F(ValidationTest, avg_pool_v1_2_nchw_relaxed_5) {
  const Model model = avg_pool_v1_2::createTestModel_nchw_relaxed_5();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nchw_relaxed_5());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, avg_pool_v1_2_nchw_quant8_5) {
  generated_tests::Execute(device,
                           avg_pool_v1_2::createTestModel_nchw_quant8_5,
                           avg_pool_v1_2::is_ignored_nchw_quant8_5,
                           avg_pool_v1_2::get_examples_nchw_quant8_5());
}

TEST_F(ValidationTest, avg_pool_v1_2_nchw_quant8_5) {
  const Model model = avg_pool_v1_2::createTestModel_nchw_quant8_5();
  const std::vector<Request> requests = createRequests(avg_pool_v1_2::get_examples_nchw_quant8_5());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: axis_aligned_bbox_transform.mod.py.
namespace axis_aligned_bbox_transform {
// Generated axis_aligned_bbox_transform test
#include "examples/axis_aligned_bbox_transform.example.cpp"
// Generated model constructor
#include "vts_models/axis_aligned_bbox_transform.model.cpp"
} // namespace axis_aligned_bbox_transform

TEST_F(NeuralnetworksHidlTest, axis_aligned_bbox_transform) {
  generated_tests::Execute(device,
                           axis_aligned_bbox_transform::createTestModel,
                           axis_aligned_bbox_transform::is_ignored,
                           axis_aligned_bbox_transform::get_examples());
}

TEST_F(ValidationTest, axis_aligned_bbox_transform) {
  const Model model = axis_aligned_bbox_transform::createTestModel();
  const std::vector<Request> requests = createRequests(axis_aligned_bbox_transform::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, axis_aligned_bbox_transform_relaxed) {
  generated_tests::Execute(device,
                           axis_aligned_bbox_transform::createTestModel_relaxed,
                           axis_aligned_bbox_transform::is_ignored_relaxed,
                           axis_aligned_bbox_transform::get_examples_relaxed());
}

TEST_F(ValidationTest, axis_aligned_bbox_transform_relaxed) {
  const Model model = axis_aligned_bbox_transform::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(axis_aligned_bbox_transform::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, axis_aligned_bbox_transform_2) {
  generated_tests::Execute(device,
                           axis_aligned_bbox_transform::createTestModel_2,
                           axis_aligned_bbox_transform::is_ignored_2,
                           axis_aligned_bbox_transform::get_examples_2());
}

TEST_F(ValidationTest, axis_aligned_bbox_transform_2) {
  const Model model = axis_aligned_bbox_transform::createTestModel_2();
  const std::vector<Request> requests = createRequests(axis_aligned_bbox_transform::get_examples_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, axis_aligned_bbox_transform_relaxed_2) {
  generated_tests::Execute(device,
                           axis_aligned_bbox_transform::createTestModel_relaxed_2,
                           axis_aligned_bbox_transform::is_ignored_relaxed_2,
                           axis_aligned_bbox_transform::get_examples_relaxed_2());
}

TEST_F(ValidationTest, axis_aligned_bbox_transform_relaxed_2) {
  const Model model = axis_aligned_bbox_transform::createTestModel_relaxed_2();
  const std::vector<Request> requests = createRequests(axis_aligned_bbox_transform::get_examples_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, axis_aligned_bbox_transform_single_batch) {
  generated_tests::Execute(device,
                           axis_aligned_bbox_transform::createTestModel_single_batch,
                           axis_aligned_bbox_transform::is_ignored_single_batch,
                           axis_aligned_bbox_transform::get_examples_single_batch());
}

TEST_F(ValidationTest, axis_aligned_bbox_transform_single_batch) {
  const Model model = axis_aligned_bbox_transform::createTestModel_single_batch();
  const std::vector<Request> requests = createRequests(axis_aligned_bbox_transform::get_examples_single_batch());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, axis_aligned_bbox_transform_single_batch_relaxed) {
  generated_tests::Execute(device,
                           axis_aligned_bbox_transform::createTestModel_single_batch_relaxed,
                           axis_aligned_bbox_transform::is_ignored_single_batch_relaxed,
                           axis_aligned_bbox_transform::get_examples_single_batch_relaxed());
}

TEST_F(ValidationTest, axis_aligned_bbox_transform_single_batch_relaxed) {
  const Model model = axis_aligned_bbox_transform::createTestModel_single_batch_relaxed();
  const std::vector<Request> requests = createRequests(axis_aligned_bbox_transform::get_examples_single_batch_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: batch_to_space_v1_2.mod.py.
namespace batch_to_space_v1_2 {
// Generated batch_to_space_v1_2 test
#include "examples/batch_to_space_v1_2.example.cpp"
// Generated model constructor
#include "vts_models/batch_to_space_v1_2.model.cpp"
} // namespace batch_to_space_v1_2

TEST_F(NeuralnetworksHidlTest, batch_to_space_v1_2_nhwc) {
  generated_tests::Execute(device,
                           batch_to_space_v1_2::createTestModel_nhwc,
                           batch_to_space_v1_2::is_ignored_nhwc,
                           batch_to_space_v1_2::get_examples_nhwc());
}

TEST_F(ValidationTest, batch_to_space_v1_2_nhwc) {
  const Model model = batch_to_space_v1_2::createTestModel_nhwc();
  const std::vector<Request> requests = createRequests(batch_to_space_v1_2::get_examples_nhwc());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, batch_to_space_v1_2_nhwc_relaxed) {
  generated_tests::Execute(device,
                           batch_to_space_v1_2::createTestModel_nhwc_relaxed,
                           batch_to_space_v1_2::is_ignored_nhwc_relaxed,
                           batch_to_space_v1_2::get_examples_nhwc_relaxed());
}

TEST_F(ValidationTest, batch_to_space_v1_2_nhwc_relaxed) {
  const Model model = batch_to_space_v1_2::createTestModel_nhwc_relaxed();
  const std::vector<Request> requests = createRequests(batch_to_space_v1_2::get_examples_nhwc_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, batch_to_space_v1_2_nhwc_float16) {
  generated_tests::Execute(device,
                           batch_to_space_v1_2::createTestModel_nhwc_float16,
                           batch_to_space_v1_2::is_ignored_nhwc_float16,
                           batch_to_space_v1_2::get_examples_nhwc_float16());
}

TEST_F(ValidationTest, batch_to_space_v1_2_nhwc_float16) {
  const Model model = batch_to_space_v1_2::createTestModel_nhwc_float16();
  const std::vector<Request> requests = createRequests(batch_to_space_v1_2::get_examples_nhwc_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, batch_to_space_v1_2_nhwc_quant8) {
  generated_tests::Execute(device,
                           batch_to_space_v1_2::createTestModel_nhwc_quant8,
                           batch_to_space_v1_2::is_ignored_nhwc_quant8,
                           batch_to_space_v1_2::get_examples_nhwc_quant8());
}

TEST_F(ValidationTest, batch_to_space_v1_2_nhwc_quant8) {
  const Model model = batch_to_space_v1_2::createTestModel_nhwc_quant8();
  const std::vector<Request> requests = createRequests(batch_to_space_v1_2::get_examples_nhwc_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, batch_to_space_v1_2_nchw) {
  generated_tests::Execute(device,
                           batch_to_space_v1_2::createTestModel_nchw,
                           batch_to_space_v1_2::is_ignored_nchw,
                           batch_to_space_v1_2::get_examples_nchw());
}

TEST_F(ValidationTest, batch_to_space_v1_2_nchw) {
  const Model model = batch_to_space_v1_2::createTestModel_nchw();
  const std::vector<Request> requests = createRequests(batch_to_space_v1_2::get_examples_nchw());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, batch_to_space_v1_2_nchw_relaxed) {
  generated_tests::Execute(device,
                           batch_to_space_v1_2::createTestModel_nchw_relaxed,
                           batch_to_space_v1_2::is_ignored_nchw_relaxed,
                           batch_to_space_v1_2::get_examples_nchw_relaxed());
}

TEST_F(ValidationTest, batch_to_space_v1_2_nchw_relaxed) {
  const Model model = batch_to_space_v1_2::createTestModel_nchw_relaxed();
  const std::vector<Request> requests = createRequests(batch_to_space_v1_2::get_examples_nchw_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, batch_to_space_v1_2_nchw_float16) {
  generated_tests::Execute(device,
                           batch_to_space_v1_2::createTestModel_nchw_float16,
                           batch_to_space_v1_2::is_ignored_nchw_float16,
                           batch_to_space_v1_2::get_examples_nchw_float16());
}

TEST_F(ValidationTest, batch_to_space_v1_2_nchw_float16) {
  const Model model = batch_to_space_v1_2::createTestModel_nchw_float16();
  const std::vector<Request> requests = createRequests(batch_to_space_v1_2::get_examples_nchw_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, batch_to_space_v1_2_nchw_quant8) {
  generated_tests::Execute(device,
                           batch_to_space_v1_2::createTestModel_nchw_quant8,
                           batch_to_space_v1_2::is_ignored_nchw_quant8,
                           batch_to_space_v1_2::get_examples_nchw_quant8());
}

TEST_F(ValidationTest, batch_to_space_v1_2_nchw_quant8) {
  const Model model = batch_to_space_v1_2::createTestModel_nchw_quant8();
  const std::vector<Request> requests = createRequests(batch_to_space_v1_2::get_examples_nchw_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, batch_to_space_v1_2_nhwc_2) {
  generated_tests::Execute(device,
                           batch_to_space_v1_2::createTestModel_nhwc_2,
                           batch_to_space_v1_2::is_ignored_nhwc_2,
                           batch_to_space_v1_2::get_examples_nhwc_2());
}

TEST_F(ValidationTest, batch_to_space_v1_2_nhwc_2) {
  const Model model = batch_to_space_v1_2::createTestModel_nhwc_2();
  const std::vector<Request> requests = createRequests(batch_to_space_v1_2::get_examples_nhwc_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, batch_to_space_v1_2_nhwc_relaxed_2) {
  generated_tests::Execute(device,
                           batch_to_space_v1_2::createTestModel_nhwc_relaxed_2,
                           batch_to_space_v1_2::is_ignored_nhwc_relaxed_2,
                           batch_to_space_v1_2::get_examples_nhwc_relaxed_2());
}

TEST_F(ValidationTest, batch_to_space_v1_2_nhwc_relaxed_2) {
  const Model model = batch_to_space_v1_2::createTestModel_nhwc_relaxed_2();
  const std::vector<Request> requests = createRequests(batch_to_space_v1_2::get_examples_nhwc_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, batch_to_space_v1_2_nhwc_float16_2) {
  generated_tests::Execute(device,
                           batch_to_space_v1_2::createTestModel_nhwc_float16_2,
                           batch_to_space_v1_2::is_ignored_nhwc_float16_2,
                           batch_to_space_v1_2::get_examples_nhwc_float16_2());
}

TEST_F(ValidationTest, batch_to_space_v1_2_nhwc_float16_2) {
  const Model model = batch_to_space_v1_2::createTestModel_nhwc_float16_2();
  const std::vector<Request> requests = createRequests(batch_to_space_v1_2::get_examples_nhwc_float16_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, batch_to_space_v1_2_nhwc_quant8_2) {
  generated_tests::Execute(device,
                           batch_to_space_v1_2::createTestModel_nhwc_quant8_2,
                           batch_to_space_v1_2::is_ignored_nhwc_quant8_2,
                           batch_to_space_v1_2::get_examples_nhwc_quant8_2());
}

TEST_F(ValidationTest, batch_to_space_v1_2_nhwc_quant8_2) {
  const Model model = batch_to_space_v1_2::createTestModel_nhwc_quant8_2();
  const std::vector<Request> requests = createRequests(batch_to_space_v1_2::get_examples_nhwc_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, batch_to_space_v1_2_nchw_2) {
  generated_tests::Execute(device,
                           batch_to_space_v1_2::createTestModel_nchw_2,
                           batch_to_space_v1_2::is_ignored_nchw_2,
                           batch_to_space_v1_2::get_examples_nchw_2());
}

TEST_F(ValidationTest, batch_to_space_v1_2_nchw_2) {
  const Model model = batch_to_space_v1_2::createTestModel_nchw_2();
  const std::vector<Request> requests = createRequests(batch_to_space_v1_2::get_examples_nchw_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, batch_to_space_v1_2_nchw_relaxed_2) {
  generated_tests::Execute(device,
                           batch_to_space_v1_2::createTestModel_nchw_relaxed_2,
                           batch_to_space_v1_2::is_ignored_nchw_relaxed_2,
                           batch_to_space_v1_2::get_examples_nchw_relaxed_2());
}

TEST_F(ValidationTest, batch_to_space_v1_2_nchw_relaxed_2) {
  const Model model = batch_to_space_v1_2::createTestModel_nchw_relaxed_2();
  const std::vector<Request> requests = createRequests(batch_to_space_v1_2::get_examples_nchw_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, batch_to_space_v1_2_nchw_float16_2) {
  generated_tests::Execute(device,
                           batch_to_space_v1_2::createTestModel_nchw_float16_2,
                           batch_to_space_v1_2::is_ignored_nchw_float16_2,
                           batch_to_space_v1_2::get_examples_nchw_float16_2());
}

TEST_F(ValidationTest, batch_to_space_v1_2_nchw_float16_2) {
  const Model model = batch_to_space_v1_2::createTestModel_nchw_float16_2();
  const std::vector<Request> requests = createRequests(batch_to_space_v1_2::get_examples_nchw_float16_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, batch_to_space_v1_2_nchw_quant8_2) {
  generated_tests::Execute(device,
                           batch_to_space_v1_2::createTestModel_nchw_quant8_2,
                           batch_to_space_v1_2::is_ignored_nchw_quant8_2,
                           batch_to_space_v1_2::get_examples_nchw_quant8_2());
}

TEST_F(ValidationTest, batch_to_space_v1_2_nchw_quant8_2) {
  const Model model = batch_to_space_v1_2::createTestModel_nchw_quant8_2();
  const std::vector<Request> requests = createRequests(batch_to_space_v1_2::get_examples_nchw_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: cast.mod.py.
namespace cast {
// Generated cast test
#include "examples/cast.example.cpp"
// Generated model constructor
#include "vts_models/cast.model.cpp"
} // namespace cast

TEST_F(NeuralnetworksHidlTest, cast_float16_to_float16) {
  generated_tests::Execute(device,
                           cast::createTestModel,
                           cast::is_ignored,
                           cast::get_examples_float16_to_float16());
}

TEST_F(ValidationTest, cast_float16_to_float16) {
  const Model model = cast::createTestModel();
  const std::vector<Request> requests = createRequests(cast::get_examples_float16_to_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, cast_float16_to_float32) {
  generated_tests::Execute(device,
                           cast::createTestModel_2,
                           cast::is_ignored_2,
                           cast::get_examples_float16_to_float32());
}

TEST_F(ValidationTest, cast_float16_to_float32) {
  const Model model = cast::createTestModel_2();
  const std::vector<Request> requests = createRequests(cast::get_examples_float16_to_float32());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, cast_float16_to_float32_relaxed) {
  generated_tests::Execute(device,
                           cast::createTestModel_relaxed,
                           cast::is_ignored_relaxed,
                           cast::get_examples_float16_to_float32_relaxed());
}

TEST_F(ValidationTest, cast_float16_to_float32_relaxed) {
  const Model model = cast::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(cast::get_examples_float16_to_float32_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, cast_float16_to_int32) {
  generated_tests::Execute(device,
                           cast::createTestModel_3,
                           cast::is_ignored_3,
                           cast::get_examples_float16_to_int32());
}

TEST_F(ValidationTest, cast_float16_to_int32) {
  const Model model = cast::createTestModel_3();
  const std::vector<Request> requests = createRequests(cast::get_examples_float16_to_int32());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, cast_float16_to_quant8) {
  generated_tests::Execute(device,
                           cast::createTestModel_4,
                           cast::is_ignored_4,
                           cast::get_examples_float16_to_quant8());
}

TEST_F(ValidationTest, cast_float16_to_quant8) {
  const Model model = cast::createTestModel_4();
  const std::vector<Request> requests = createRequests(cast::get_examples_float16_to_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, cast_float32_to_float16) {
  generated_tests::Execute(device,
                           cast::createTestModel_5,
                           cast::is_ignored_5,
                           cast::get_examples_float32_to_float16());
}

TEST_F(ValidationTest, cast_float32_to_float16) {
  const Model model = cast::createTestModel_5();
  const std::vector<Request> requests = createRequests(cast::get_examples_float32_to_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, cast_float32_to_float16_relaxed) {
  generated_tests::Execute(device,
                           cast::createTestModel_relaxed_2,
                           cast::is_ignored_relaxed_2,
                           cast::get_examples_float32_to_float16_relaxed());
}

TEST_F(ValidationTest, cast_float32_to_float16_relaxed) {
  const Model model = cast::createTestModel_relaxed_2();
  const std::vector<Request> requests = createRequests(cast::get_examples_float32_to_float16_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, cast_float32_to_float32) {
  generated_tests::Execute(device,
                           cast::createTestModel_6,
                           cast::is_ignored_6,
                           cast::get_examples_float32_to_float32());
}

TEST_F(ValidationTest, cast_float32_to_float32) {
  const Model model = cast::createTestModel_6();
  const std::vector<Request> requests = createRequests(cast::get_examples_float32_to_float32());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, cast_float32_to_float32_relaxed) {
  generated_tests::Execute(device,
                           cast::createTestModel_relaxed_3,
                           cast::is_ignored_relaxed_3,
                           cast::get_examples_float32_to_float32_relaxed());
}

TEST_F(ValidationTest, cast_float32_to_float32_relaxed) {
  const Model model = cast::createTestModel_relaxed_3();
  const std::vector<Request> requests = createRequests(cast::get_examples_float32_to_float32_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, cast_float32_to_int32) {
  generated_tests::Execute(device,
                           cast::createTestModel_7,
                           cast::is_ignored_7,
                           cast::get_examples_float32_to_int32());
}

TEST_F(ValidationTest, cast_float32_to_int32) {
  const Model model = cast::createTestModel_7();
  const std::vector<Request> requests = createRequests(cast::get_examples_float32_to_int32());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, cast_float32_to_int32_relaxed) {
  generated_tests::Execute(device,
                           cast::createTestModel_relaxed_4,
                           cast::is_ignored_relaxed_4,
                           cast::get_examples_float32_to_int32_relaxed());
}

TEST_F(ValidationTest, cast_float32_to_int32_relaxed) {
  const Model model = cast::createTestModel_relaxed_4();
  const std::vector<Request> requests = createRequests(cast::get_examples_float32_to_int32_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, cast_float32_to_quant8) {
  generated_tests::Execute(device,
                           cast::createTestModel_8,
                           cast::is_ignored_8,
                           cast::get_examples_float32_to_quant8());
}

TEST_F(ValidationTest, cast_float32_to_quant8) {
  const Model model = cast::createTestModel_8();
  const std::vector<Request> requests = createRequests(cast::get_examples_float32_to_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, cast_float32_to_quant8_relaxed) {
  generated_tests::Execute(device,
                           cast::createTestModel_relaxed_5,
                           cast::is_ignored_relaxed_5,
                           cast::get_examples_float32_to_quant8_relaxed());
}

TEST_F(ValidationTest, cast_float32_to_quant8_relaxed) {
  const Model model = cast::createTestModel_relaxed_5();
  const std::vector<Request> requests = createRequests(cast::get_examples_float32_to_quant8_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, cast_int32_to_float16) {
  generated_tests::Execute(device,
                           cast::createTestModel_9,
                           cast::is_ignored_9,
                           cast::get_examples_int32_to_float16());
}

TEST_F(ValidationTest, cast_int32_to_float16) {
  const Model model = cast::createTestModel_9();
  const std::vector<Request> requests = createRequests(cast::get_examples_int32_to_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, cast_int32_to_float32) {
  generated_tests::Execute(device,
                           cast::createTestModel_10,
                           cast::is_ignored_10,
                           cast::get_examples_int32_to_float32());
}

TEST_F(ValidationTest, cast_int32_to_float32) {
  const Model model = cast::createTestModel_10();
  const std::vector<Request> requests = createRequests(cast::get_examples_int32_to_float32());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, cast_int32_to_float32_relaxed) {
  generated_tests::Execute(device,
                           cast::createTestModel_relaxed_6,
                           cast::is_ignored_relaxed_6,
                           cast::get_examples_int32_to_float32_relaxed());
}

TEST_F(ValidationTest, cast_int32_to_float32_relaxed) {
  const Model model = cast::createTestModel_relaxed_6();
  const std::vector<Request> requests = createRequests(cast::get_examples_int32_to_float32_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, cast_int32_to_int32) {
  generated_tests::Execute(device,
                           cast::createTestModel_11,
                           cast::is_ignored_11,
                           cast::get_examples_int32_to_int32());
}

TEST_F(ValidationTest, cast_int32_to_int32) {
  const Model model = cast::createTestModel_11();
  const std::vector<Request> requests = createRequests(cast::get_examples_int32_to_int32());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, cast_int32_to_quant8) {
  generated_tests::Execute(device,
                           cast::createTestModel_12,
                           cast::is_ignored_12,
                           cast::get_examples_int32_to_quant8());
}

TEST_F(ValidationTest, cast_int32_to_quant8) {
  const Model model = cast::createTestModel_12();
  const std::vector<Request> requests = createRequests(cast::get_examples_int32_to_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, cast_quant8_to_float16) {
  generated_tests::Execute(device,
                           cast::createTestModel_13,
                           cast::is_ignored_13,
                           cast::get_examples_quant8_to_float16());
}

TEST_F(ValidationTest, cast_quant8_to_float16) {
  const Model model = cast::createTestModel_13();
  const std::vector<Request> requests = createRequests(cast::get_examples_quant8_to_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, cast_quant8_to_float32) {
  generated_tests::Execute(device,
                           cast::createTestModel_14,
                           cast::is_ignored_14,
                           cast::get_examples_quant8_to_float32());
}

TEST_F(ValidationTest, cast_quant8_to_float32) {
  const Model model = cast::createTestModel_14();
  const std::vector<Request> requests = createRequests(cast::get_examples_quant8_to_float32());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, cast_quant8_to_float32_relaxed) {
  generated_tests::Execute(device,
                           cast::createTestModel_relaxed_7,
                           cast::is_ignored_relaxed_7,
                           cast::get_examples_quant8_to_float32_relaxed());
}

TEST_F(ValidationTest, cast_quant8_to_float32_relaxed) {
  const Model model = cast::createTestModel_relaxed_7();
  const std::vector<Request> requests = createRequests(cast::get_examples_quant8_to_float32_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, cast_quant8_to_int32) {
  generated_tests::Execute(device,
                           cast::createTestModel_15,
                           cast::is_ignored_15,
                           cast::get_examples_quant8_to_int32());
}

TEST_F(ValidationTest, cast_quant8_to_int32) {
  const Model model = cast::createTestModel_15();
  const std::vector<Request> requests = createRequests(cast::get_examples_quant8_to_int32());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, cast_quant8_to_quant8) {
  generated_tests::Execute(device,
                           cast::createTestModel_16,
                           cast::is_ignored_16,
                           cast::get_examples_quant8_to_quant8());
}

TEST_F(ValidationTest, cast_quant8_to_quant8) {
  const Model model = cast::createTestModel_16();
  const std::vector<Request> requests = createRequests(cast::get_examples_quant8_to_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: channel_shuffle.mod.py.
namespace channel_shuffle {
// Generated channel_shuffle test
#include "examples/channel_shuffle.example.cpp"
// Generated model constructor
#include "vts_models/channel_shuffle.model.cpp"
} // namespace channel_shuffle

TEST_F(NeuralnetworksHidlTest, channel_shuffle_dim4_axis0) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_dim4_axis0,
                           channel_shuffle::is_ignored_dim4_axis0,
                           channel_shuffle::get_examples_dim4_axis0());
}

TEST_F(ValidationTest, channel_shuffle_dim4_axis0) {
  const Model model = channel_shuffle::createTestModel_dim4_axis0();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_dim4_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_dim4_axis0_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_dim4_axis0_neg,
                           channel_shuffle::is_ignored_dim4_axis0_neg,
                           channel_shuffle::get_examples_dim4_axis0_neg());
}

TEST_F(ValidationTest, channel_shuffle_dim4_axis0_neg) {
  const Model model = channel_shuffle::createTestModel_dim4_axis0_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_dim4_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_dim4_axis1) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_dim4_axis1,
                           channel_shuffle::is_ignored_dim4_axis1,
                           channel_shuffle::get_examples_dim4_axis1());
}

TEST_F(ValidationTest, channel_shuffle_dim4_axis1) {
  const Model model = channel_shuffle::createTestModel_dim4_axis1();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_dim4_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_dim4_axis1_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_dim4_axis1_neg,
                           channel_shuffle::is_ignored_dim4_axis1_neg,
                           channel_shuffle::get_examples_dim4_axis1_neg());
}

TEST_F(ValidationTest, channel_shuffle_dim4_axis1_neg) {
  const Model model = channel_shuffle::createTestModel_dim4_axis1_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_dim4_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_dim4_axis2) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_dim4_axis2,
                           channel_shuffle::is_ignored_dim4_axis2,
                           channel_shuffle::get_examples_dim4_axis2());
}

TEST_F(ValidationTest, channel_shuffle_dim4_axis2) {
  const Model model = channel_shuffle::createTestModel_dim4_axis2();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_dim4_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_dim4_axis2_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_dim4_axis2_neg,
                           channel_shuffle::is_ignored_dim4_axis2_neg,
                           channel_shuffle::get_examples_dim4_axis2_neg());
}

TEST_F(ValidationTest, channel_shuffle_dim4_axis2_neg) {
  const Model model = channel_shuffle::createTestModel_dim4_axis2_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_dim4_axis2_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_dim4_axis3) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_dim4_axis3,
                           channel_shuffle::is_ignored_dim4_axis3,
                           channel_shuffle::get_examples_dim4_axis3());
}

TEST_F(ValidationTest, channel_shuffle_dim4_axis3) {
  const Model model = channel_shuffle::createTestModel_dim4_axis3();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_dim4_axis3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_dim4_axis3_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_dim4_axis3_neg,
                           channel_shuffle::is_ignored_dim4_axis3_neg,
                           channel_shuffle::get_examples_dim4_axis3_neg());
}

TEST_F(ValidationTest, channel_shuffle_dim4_axis3_neg) {
  const Model model = channel_shuffle::createTestModel_dim4_axis3_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_dim4_axis3_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_dim3_axis0) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_dim3_axis0,
                           channel_shuffle::is_ignored_dim3_axis0,
                           channel_shuffle::get_examples_dim3_axis0());
}

TEST_F(ValidationTest, channel_shuffle_dim3_axis0) {
  const Model model = channel_shuffle::createTestModel_dim3_axis0();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_dim3_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_dim3_axis0_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_dim3_axis0_neg,
                           channel_shuffle::is_ignored_dim3_axis0_neg,
                           channel_shuffle::get_examples_dim3_axis0_neg());
}

TEST_F(ValidationTest, channel_shuffle_dim3_axis0_neg) {
  const Model model = channel_shuffle::createTestModel_dim3_axis0_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_dim3_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_dim3_axis1) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_dim3_axis1,
                           channel_shuffle::is_ignored_dim3_axis1,
                           channel_shuffle::get_examples_dim3_axis1());
}

TEST_F(ValidationTest, channel_shuffle_dim3_axis1) {
  const Model model = channel_shuffle::createTestModel_dim3_axis1();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_dim3_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_dim3_axis1_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_dim3_axis1_neg,
                           channel_shuffle::is_ignored_dim3_axis1_neg,
                           channel_shuffle::get_examples_dim3_axis1_neg());
}

TEST_F(ValidationTest, channel_shuffle_dim3_axis1_neg) {
  const Model model = channel_shuffle::createTestModel_dim3_axis1_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_dim3_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_dim3_axis2) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_dim3_axis2,
                           channel_shuffle::is_ignored_dim3_axis2,
                           channel_shuffle::get_examples_dim3_axis2());
}

TEST_F(ValidationTest, channel_shuffle_dim3_axis2) {
  const Model model = channel_shuffle::createTestModel_dim3_axis2();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_dim3_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_dim3_axis2_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_dim3_axis2_neg,
                           channel_shuffle::is_ignored_dim3_axis2_neg,
                           channel_shuffle::get_examples_dim3_axis2_neg());
}

TEST_F(ValidationTest, channel_shuffle_dim3_axis2_neg) {
  const Model model = channel_shuffle::createTestModel_dim3_axis2_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_dim3_axis2_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_dim2_axis0) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_dim2_axis0,
                           channel_shuffle::is_ignored_dim2_axis0,
                           channel_shuffle::get_examples_dim2_axis0());
}

TEST_F(ValidationTest, channel_shuffle_dim2_axis0) {
  const Model model = channel_shuffle::createTestModel_dim2_axis0();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_dim2_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_dim2_axis0_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_dim2_axis0_neg,
                           channel_shuffle::is_ignored_dim2_axis0_neg,
                           channel_shuffle::get_examples_dim2_axis0_neg());
}

TEST_F(ValidationTest, channel_shuffle_dim2_axis0_neg) {
  const Model model = channel_shuffle::createTestModel_dim2_axis0_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_dim2_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_dim2_axis1) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_dim2_axis1,
                           channel_shuffle::is_ignored_dim2_axis1,
                           channel_shuffle::get_examples_dim2_axis1());
}

TEST_F(ValidationTest, channel_shuffle_dim2_axis1) {
  const Model model = channel_shuffle::createTestModel_dim2_axis1();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_dim2_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_dim2_axis1_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_dim2_axis1_neg,
                           channel_shuffle::is_ignored_dim2_axis1_neg,
                           channel_shuffle::get_examples_dim2_axis1_neg());
}

TEST_F(ValidationTest, channel_shuffle_dim2_axis1_neg) {
  const Model model = channel_shuffle::createTestModel_dim2_axis1_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_dim2_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_dim1_axis0) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_dim1_axis0,
                           channel_shuffle::is_ignored_dim1_axis0,
                           channel_shuffle::get_examples_dim1_axis0());
}

TEST_F(ValidationTest, channel_shuffle_dim1_axis0) {
  const Model model = channel_shuffle::createTestModel_dim1_axis0();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_dim1_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_dim1_axis0_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_dim1_axis0_neg,
                           channel_shuffle::is_ignored_dim1_axis0_neg,
                           channel_shuffle::get_examples_dim1_axis0_neg());
}

TEST_F(ValidationTest, channel_shuffle_dim1_axis0_neg) {
  const Model model = channel_shuffle::createTestModel_dim1_axis0_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_dim1_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_relaxed_dim4_axis0) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_relaxed_dim4_axis0,
                           channel_shuffle::is_ignored_relaxed_dim4_axis0,
                           channel_shuffle::get_examples_relaxed_dim4_axis0());
}

TEST_F(ValidationTest, channel_shuffle_relaxed_dim4_axis0) {
  const Model model = channel_shuffle::createTestModel_relaxed_dim4_axis0();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_relaxed_dim4_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_relaxed_dim4_axis0_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_relaxed_dim4_axis0_neg,
                           channel_shuffle::is_ignored_relaxed_dim4_axis0_neg,
                           channel_shuffle::get_examples_relaxed_dim4_axis0_neg());
}

TEST_F(ValidationTest, channel_shuffle_relaxed_dim4_axis0_neg) {
  const Model model = channel_shuffle::createTestModel_relaxed_dim4_axis0_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_relaxed_dim4_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_relaxed_dim4_axis1) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_relaxed_dim4_axis1,
                           channel_shuffle::is_ignored_relaxed_dim4_axis1,
                           channel_shuffle::get_examples_relaxed_dim4_axis1());
}

TEST_F(ValidationTest, channel_shuffle_relaxed_dim4_axis1) {
  const Model model = channel_shuffle::createTestModel_relaxed_dim4_axis1();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_relaxed_dim4_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_relaxed_dim4_axis1_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_relaxed_dim4_axis1_neg,
                           channel_shuffle::is_ignored_relaxed_dim4_axis1_neg,
                           channel_shuffle::get_examples_relaxed_dim4_axis1_neg());
}

TEST_F(ValidationTest, channel_shuffle_relaxed_dim4_axis1_neg) {
  const Model model = channel_shuffle::createTestModel_relaxed_dim4_axis1_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_relaxed_dim4_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_relaxed_dim4_axis2) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_relaxed_dim4_axis2,
                           channel_shuffle::is_ignored_relaxed_dim4_axis2,
                           channel_shuffle::get_examples_relaxed_dim4_axis2());
}

TEST_F(ValidationTest, channel_shuffle_relaxed_dim4_axis2) {
  const Model model = channel_shuffle::createTestModel_relaxed_dim4_axis2();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_relaxed_dim4_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_relaxed_dim4_axis2_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_relaxed_dim4_axis2_neg,
                           channel_shuffle::is_ignored_relaxed_dim4_axis2_neg,
                           channel_shuffle::get_examples_relaxed_dim4_axis2_neg());
}

TEST_F(ValidationTest, channel_shuffle_relaxed_dim4_axis2_neg) {
  const Model model = channel_shuffle::createTestModel_relaxed_dim4_axis2_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_relaxed_dim4_axis2_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_relaxed_dim4_axis3) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_relaxed_dim4_axis3,
                           channel_shuffle::is_ignored_relaxed_dim4_axis3,
                           channel_shuffle::get_examples_relaxed_dim4_axis3());
}

TEST_F(ValidationTest, channel_shuffle_relaxed_dim4_axis3) {
  const Model model = channel_shuffle::createTestModel_relaxed_dim4_axis3();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_relaxed_dim4_axis3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_relaxed_dim4_axis3_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_relaxed_dim4_axis3_neg,
                           channel_shuffle::is_ignored_relaxed_dim4_axis3_neg,
                           channel_shuffle::get_examples_relaxed_dim4_axis3_neg());
}

TEST_F(ValidationTest, channel_shuffle_relaxed_dim4_axis3_neg) {
  const Model model = channel_shuffle::createTestModel_relaxed_dim4_axis3_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_relaxed_dim4_axis3_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_relaxed_dim3_axis0) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_relaxed_dim3_axis0,
                           channel_shuffle::is_ignored_relaxed_dim3_axis0,
                           channel_shuffle::get_examples_relaxed_dim3_axis0());
}

TEST_F(ValidationTest, channel_shuffle_relaxed_dim3_axis0) {
  const Model model = channel_shuffle::createTestModel_relaxed_dim3_axis0();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_relaxed_dim3_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_relaxed_dim3_axis0_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_relaxed_dim3_axis0_neg,
                           channel_shuffle::is_ignored_relaxed_dim3_axis0_neg,
                           channel_shuffle::get_examples_relaxed_dim3_axis0_neg());
}

TEST_F(ValidationTest, channel_shuffle_relaxed_dim3_axis0_neg) {
  const Model model = channel_shuffle::createTestModel_relaxed_dim3_axis0_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_relaxed_dim3_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_relaxed_dim3_axis1) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_relaxed_dim3_axis1,
                           channel_shuffle::is_ignored_relaxed_dim3_axis1,
                           channel_shuffle::get_examples_relaxed_dim3_axis1());
}

TEST_F(ValidationTest, channel_shuffle_relaxed_dim3_axis1) {
  const Model model = channel_shuffle::createTestModel_relaxed_dim3_axis1();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_relaxed_dim3_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_relaxed_dim3_axis1_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_relaxed_dim3_axis1_neg,
                           channel_shuffle::is_ignored_relaxed_dim3_axis1_neg,
                           channel_shuffle::get_examples_relaxed_dim3_axis1_neg());
}

TEST_F(ValidationTest, channel_shuffle_relaxed_dim3_axis1_neg) {
  const Model model = channel_shuffle::createTestModel_relaxed_dim3_axis1_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_relaxed_dim3_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_relaxed_dim3_axis2) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_relaxed_dim3_axis2,
                           channel_shuffle::is_ignored_relaxed_dim3_axis2,
                           channel_shuffle::get_examples_relaxed_dim3_axis2());
}

TEST_F(ValidationTest, channel_shuffle_relaxed_dim3_axis2) {
  const Model model = channel_shuffle::createTestModel_relaxed_dim3_axis2();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_relaxed_dim3_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_relaxed_dim3_axis2_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_relaxed_dim3_axis2_neg,
                           channel_shuffle::is_ignored_relaxed_dim3_axis2_neg,
                           channel_shuffle::get_examples_relaxed_dim3_axis2_neg());
}

TEST_F(ValidationTest, channel_shuffle_relaxed_dim3_axis2_neg) {
  const Model model = channel_shuffle::createTestModel_relaxed_dim3_axis2_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_relaxed_dim3_axis2_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_relaxed_dim2_axis0) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_relaxed_dim2_axis0,
                           channel_shuffle::is_ignored_relaxed_dim2_axis0,
                           channel_shuffle::get_examples_relaxed_dim2_axis0());
}

TEST_F(ValidationTest, channel_shuffle_relaxed_dim2_axis0) {
  const Model model = channel_shuffle::createTestModel_relaxed_dim2_axis0();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_relaxed_dim2_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_relaxed_dim2_axis0_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_relaxed_dim2_axis0_neg,
                           channel_shuffle::is_ignored_relaxed_dim2_axis0_neg,
                           channel_shuffle::get_examples_relaxed_dim2_axis0_neg());
}

TEST_F(ValidationTest, channel_shuffle_relaxed_dim2_axis0_neg) {
  const Model model = channel_shuffle::createTestModel_relaxed_dim2_axis0_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_relaxed_dim2_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_relaxed_dim2_axis1) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_relaxed_dim2_axis1,
                           channel_shuffle::is_ignored_relaxed_dim2_axis1,
                           channel_shuffle::get_examples_relaxed_dim2_axis1());
}

TEST_F(ValidationTest, channel_shuffle_relaxed_dim2_axis1) {
  const Model model = channel_shuffle::createTestModel_relaxed_dim2_axis1();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_relaxed_dim2_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_relaxed_dim2_axis1_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_relaxed_dim2_axis1_neg,
                           channel_shuffle::is_ignored_relaxed_dim2_axis1_neg,
                           channel_shuffle::get_examples_relaxed_dim2_axis1_neg());
}

TEST_F(ValidationTest, channel_shuffle_relaxed_dim2_axis1_neg) {
  const Model model = channel_shuffle::createTestModel_relaxed_dim2_axis1_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_relaxed_dim2_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_relaxed_dim1_axis0) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_relaxed_dim1_axis0,
                           channel_shuffle::is_ignored_relaxed_dim1_axis0,
                           channel_shuffle::get_examples_relaxed_dim1_axis0());
}

TEST_F(ValidationTest, channel_shuffle_relaxed_dim1_axis0) {
  const Model model = channel_shuffle::createTestModel_relaxed_dim1_axis0();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_relaxed_dim1_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_relaxed_dim1_axis0_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_relaxed_dim1_axis0_neg,
                           channel_shuffle::is_ignored_relaxed_dim1_axis0_neg,
                           channel_shuffle::get_examples_relaxed_dim1_axis0_neg());
}

TEST_F(ValidationTest, channel_shuffle_relaxed_dim1_axis0_neg) {
  const Model model = channel_shuffle::createTestModel_relaxed_dim1_axis0_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_relaxed_dim1_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_quant8_dim4_axis0) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_quant8_dim4_axis0,
                           channel_shuffle::is_ignored_quant8_dim4_axis0,
                           channel_shuffle::get_examples_quant8_dim4_axis0());
}

TEST_F(ValidationTest, channel_shuffle_quant8_dim4_axis0) {
  const Model model = channel_shuffle::createTestModel_quant8_dim4_axis0();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_quant8_dim4_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_quant8_dim4_axis0_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_quant8_dim4_axis0_neg,
                           channel_shuffle::is_ignored_quant8_dim4_axis0_neg,
                           channel_shuffle::get_examples_quant8_dim4_axis0_neg());
}

TEST_F(ValidationTest, channel_shuffle_quant8_dim4_axis0_neg) {
  const Model model = channel_shuffle::createTestModel_quant8_dim4_axis0_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_quant8_dim4_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_quant8_dim4_axis1) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_quant8_dim4_axis1,
                           channel_shuffle::is_ignored_quant8_dim4_axis1,
                           channel_shuffle::get_examples_quant8_dim4_axis1());
}

TEST_F(ValidationTest, channel_shuffle_quant8_dim4_axis1) {
  const Model model = channel_shuffle::createTestModel_quant8_dim4_axis1();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_quant8_dim4_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_quant8_dim4_axis1_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_quant8_dim4_axis1_neg,
                           channel_shuffle::is_ignored_quant8_dim4_axis1_neg,
                           channel_shuffle::get_examples_quant8_dim4_axis1_neg());
}

TEST_F(ValidationTest, channel_shuffle_quant8_dim4_axis1_neg) {
  const Model model = channel_shuffle::createTestModel_quant8_dim4_axis1_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_quant8_dim4_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_quant8_dim4_axis2) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_quant8_dim4_axis2,
                           channel_shuffle::is_ignored_quant8_dim4_axis2,
                           channel_shuffle::get_examples_quant8_dim4_axis2());
}

TEST_F(ValidationTest, channel_shuffle_quant8_dim4_axis2) {
  const Model model = channel_shuffle::createTestModel_quant8_dim4_axis2();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_quant8_dim4_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_quant8_dim4_axis2_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_quant8_dim4_axis2_neg,
                           channel_shuffle::is_ignored_quant8_dim4_axis2_neg,
                           channel_shuffle::get_examples_quant8_dim4_axis2_neg());
}

TEST_F(ValidationTest, channel_shuffle_quant8_dim4_axis2_neg) {
  const Model model = channel_shuffle::createTestModel_quant8_dim4_axis2_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_quant8_dim4_axis2_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_quant8_dim4_axis3) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_quant8_dim4_axis3,
                           channel_shuffle::is_ignored_quant8_dim4_axis3,
                           channel_shuffle::get_examples_quant8_dim4_axis3());
}

TEST_F(ValidationTest, channel_shuffle_quant8_dim4_axis3) {
  const Model model = channel_shuffle::createTestModel_quant8_dim4_axis3();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_quant8_dim4_axis3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_quant8_dim4_axis3_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_quant8_dim4_axis3_neg,
                           channel_shuffle::is_ignored_quant8_dim4_axis3_neg,
                           channel_shuffle::get_examples_quant8_dim4_axis3_neg());
}

TEST_F(ValidationTest, channel_shuffle_quant8_dim4_axis3_neg) {
  const Model model = channel_shuffle::createTestModel_quant8_dim4_axis3_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_quant8_dim4_axis3_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_quant8_dim3_axis0) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_quant8_dim3_axis0,
                           channel_shuffle::is_ignored_quant8_dim3_axis0,
                           channel_shuffle::get_examples_quant8_dim3_axis0());
}

TEST_F(ValidationTest, channel_shuffle_quant8_dim3_axis0) {
  const Model model = channel_shuffle::createTestModel_quant8_dim3_axis0();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_quant8_dim3_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_quant8_dim3_axis0_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_quant8_dim3_axis0_neg,
                           channel_shuffle::is_ignored_quant8_dim3_axis0_neg,
                           channel_shuffle::get_examples_quant8_dim3_axis0_neg());
}

TEST_F(ValidationTest, channel_shuffle_quant8_dim3_axis0_neg) {
  const Model model = channel_shuffle::createTestModel_quant8_dim3_axis0_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_quant8_dim3_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_quant8_dim3_axis1) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_quant8_dim3_axis1,
                           channel_shuffle::is_ignored_quant8_dim3_axis1,
                           channel_shuffle::get_examples_quant8_dim3_axis1());
}

TEST_F(ValidationTest, channel_shuffle_quant8_dim3_axis1) {
  const Model model = channel_shuffle::createTestModel_quant8_dim3_axis1();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_quant8_dim3_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_quant8_dim3_axis1_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_quant8_dim3_axis1_neg,
                           channel_shuffle::is_ignored_quant8_dim3_axis1_neg,
                           channel_shuffle::get_examples_quant8_dim3_axis1_neg());
}

TEST_F(ValidationTest, channel_shuffle_quant8_dim3_axis1_neg) {
  const Model model = channel_shuffle::createTestModel_quant8_dim3_axis1_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_quant8_dim3_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_quant8_dim3_axis2) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_quant8_dim3_axis2,
                           channel_shuffle::is_ignored_quant8_dim3_axis2,
                           channel_shuffle::get_examples_quant8_dim3_axis2());
}

TEST_F(ValidationTest, channel_shuffle_quant8_dim3_axis2) {
  const Model model = channel_shuffle::createTestModel_quant8_dim3_axis2();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_quant8_dim3_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_quant8_dim3_axis2_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_quant8_dim3_axis2_neg,
                           channel_shuffle::is_ignored_quant8_dim3_axis2_neg,
                           channel_shuffle::get_examples_quant8_dim3_axis2_neg());
}

TEST_F(ValidationTest, channel_shuffle_quant8_dim3_axis2_neg) {
  const Model model = channel_shuffle::createTestModel_quant8_dim3_axis2_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_quant8_dim3_axis2_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_quant8_dim2_axis0) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_quant8_dim2_axis0,
                           channel_shuffle::is_ignored_quant8_dim2_axis0,
                           channel_shuffle::get_examples_quant8_dim2_axis0());
}

TEST_F(ValidationTest, channel_shuffle_quant8_dim2_axis0) {
  const Model model = channel_shuffle::createTestModel_quant8_dim2_axis0();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_quant8_dim2_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_quant8_dim2_axis0_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_quant8_dim2_axis0_neg,
                           channel_shuffle::is_ignored_quant8_dim2_axis0_neg,
                           channel_shuffle::get_examples_quant8_dim2_axis0_neg());
}

TEST_F(ValidationTest, channel_shuffle_quant8_dim2_axis0_neg) {
  const Model model = channel_shuffle::createTestModel_quant8_dim2_axis0_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_quant8_dim2_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_quant8_dim2_axis1) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_quant8_dim2_axis1,
                           channel_shuffle::is_ignored_quant8_dim2_axis1,
                           channel_shuffle::get_examples_quant8_dim2_axis1());
}

TEST_F(ValidationTest, channel_shuffle_quant8_dim2_axis1) {
  const Model model = channel_shuffle::createTestModel_quant8_dim2_axis1();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_quant8_dim2_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_quant8_dim2_axis1_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_quant8_dim2_axis1_neg,
                           channel_shuffle::is_ignored_quant8_dim2_axis1_neg,
                           channel_shuffle::get_examples_quant8_dim2_axis1_neg());
}

TEST_F(ValidationTest, channel_shuffle_quant8_dim2_axis1_neg) {
  const Model model = channel_shuffle::createTestModel_quant8_dim2_axis1_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_quant8_dim2_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_quant8_dim1_axis0) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_quant8_dim1_axis0,
                           channel_shuffle::is_ignored_quant8_dim1_axis0,
                           channel_shuffle::get_examples_quant8_dim1_axis0());
}

TEST_F(ValidationTest, channel_shuffle_quant8_dim1_axis0) {
  const Model model = channel_shuffle::createTestModel_quant8_dim1_axis0();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_quant8_dim1_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, channel_shuffle_quant8_dim1_axis0_neg) {
  generated_tests::Execute(device,
                           channel_shuffle::createTestModel_quant8_dim1_axis0_neg,
                           channel_shuffle::is_ignored_quant8_dim1_axis0_neg,
                           channel_shuffle::get_examples_quant8_dim1_axis0_neg());
}

TEST_F(ValidationTest, channel_shuffle_quant8_dim1_axis0_neg) {
  const Model model = channel_shuffle::createTestModel_quant8_dim1_axis0_neg();
  const std::vector<Request> requests = createRequests(channel_shuffle::get_examples_quant8_dim1_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: concat_float16_1.mod.py.
namespace concat_float16_1 {
// Generated concat_float16_1 test
#include "examples/concat_float16_1.example.cpp"
// Generated model constructor
#include "vts_models/concat_float16_1.model.cpp"
} // namespace concat_float16_1

TEST_F(NeuralnetworksHidlTest, concat_float16_1) {
  generated_tests::Execute(device,
                           concat_float16_1::createTestModel,
                           concat_float16_1::is_ignored,
                           concat_float16_1::get_examples());
}

TEST_F(ValidationTest, concat_float16_1) {
  const Model model = concat_float16_1::createTestModel();
  const std::vector<Request> requests = createRequests(concat_float16_1::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: concat_float16_2.mod.py.
namespace concat_float16_2 {
// Generated concat_float16_2 test
#include "examples/concat_float16_2.example.cpp"
// Generated model constructor
#include "vts_models/concat_float16_2.model.cpp"
} // namespace concat_float16_2

TEST_F(NeuralnetworksHidlTest, concat_float16_2) {
  generated_tests::Execute(device,
                           concat_float16_2::createTestModel,
                           concat_float16_2::is_ignored,
                           concat_float16_2::get_examples());
}

TEST_F(ValidationTest, concat_float16_2) {
  const Model model = concat_float16_2::createTestModel();
  const std::vector<Request> requests = createRequests(concat_float16_2::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: concat_float16_3.mod.py.
namespace concat_float16_3 {
// Generated concat_float16_3 test
#include "examples/concat_float16_3.example.cpp"
// Generated model constructor
#include "vts_models/concat_float16_3.model.cpp"
} // namespace concat_float16_3

TEST_F(NeuralnetworksHidlTest, concat_float16_3) {
  generated_tests::Execute(device,
                           concat_float16_3::createTestModel,
                           concat_float16_3::is_ignored,
                           concat_float16_3::get_examples());
}

TEST_F(ValidationTest, concat_float16_3) {
  const Model model = concat_float16_3::createTestModel();
  const std::vector<Request> requests = createRequests(concat_float16_3::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: concat_mixed_quant.mod.py.
namespace concat_mixed_quant {
// Generated concat_mixed_quant test
#include "examples/concat_mixed_quant.example.cpp"
// Generated model constructor
#include "vts_models/concat_mixed_quant.model.cpp"
} // namespace concat_mixed_quant

TEST_F(NeuralnetworksHidlTest, concat_mixed_quant_quant8) {
  generated_tests::Execute(device,
                           concat_mixed_quant::createTestModel_quant8,
                           concat_mixed_quant::is_ignored_quant8,
                           concat_mixed_quant::get_examples_quant8());
}

TEST_F(ValidationTest, concat_mixed_quant_quant8) {
  const Model model = concat_mixed_quant::createTestModel_quant8();
  const std::vector<Request> requests = createRequests(concat_mixed_quant::get_examples_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, concat_mixed_quant_quant8_2) {
  generated_tests::Execute(device,
                           concat_mixed_quant::createTestModel_quant8_2,
                           concat_mixed_quant::is_ignored_quant8_2,
                           concat_mixed_quant::get_examples_quant8_2());
}

TEST_F(ValidationTest, concat_mixed_quant_quant8_2) {
  const Model model = concat_mixed_quant::createTestModel_quant8_2();
  const std::vector<Request> requests = createRequests(concat_mixed_quant::get_examples_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: conv2d_v1_2.mod.py.
namespace conv2d_v1_2 {
// Generated conv2d_v1_2 test
#include "examples/conv2d_v1_2.example.cpp"
// Generated model constructor
#include "vts_models/conv2d_v1_2.model.cpp"
} // namespace conv2d_v1_2

TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nhwc) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nhwc,
                           conv2d_v1_2::is_ignored_nhwc,
                           conv2d_v1_2::get_examples_nhwc());
}

TEST_F(ValidationTest, conv2d_v1_2_nhwc) {
  const Model model = conv2d_v1_2::createTestModel_nhwc();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nhwc());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nhwc_relaxed) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nhwc_relaxed,
                           conv2d_v1_2::is_ignored_nhwc_relaxed,
                           conv2d_v1_2::get_examples_nhwc_relaxed());
}

TEST_F(ValidationTest, conv2d_v1_2_nhwc_relaxed) {
  const Model model = conv2d_v1_2::createTestModel_nhwc_relaxed();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nhwc_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nhwc_quant8) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nhwc_quant8,
                           conv2d_v1_2::is_ignored_nhwc_quant8,
                           conv2d_v1_2::get_examples_nhwc_quant8());
}

TEST_F(ValidationTest, conv2d_v1_2_nhwc_quant8) {
  const Model model = conv2d_v1_2::createTestModel_nhwc_quant8();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nhwc_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nhwc_weight_as_input) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nhwc_weight_as_input,
                           conv2d_v1_2::is_ignored_nhwc_weight_as_input,
                           conv2d_v1_2::get_examples_nhwc_weight_as_input());
}

TEST_F(ValidationTest, conv2d_v1_2_nhwc_weight_as_input) {
  const Model model = conv2d_v1_2::createTestModel_nhwc_weight_as_input();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nhwc_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nhwc_weight_as_input_relaxed) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nhwc_weight_as_input_relaxed,
                           conv2d_v1_2::is_ignored_nhwc_weight_as_input_relaxed,
                           conv2d_v1_2::get_examples_nhwc_weight_as_input_relaxed());
}

TEST_F(ValidationTest, conv2d_v1_2_nhwc_weight_as_input_relaxed) {
  const Model model = conv2d_v1_2::createTestModel_nhwc_weight_as_input_relaxed();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nhwc_weight_as_input_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nhwc_weight_as_input_quant8) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nhwc_weight_as_input_quant8,
                           conv2d_v1_2::is_ignored_nhwc_weight_as_input_quant8,
                           conv2d_v1_2::get_examples_nhwc_weight_as_input_quant8());
}

TEST_F(ValidationTest, conv2d_v1_2_nhwc_weight_as_input_quant8) {
  const Model model = conv2d_v1_2::createTestModel_nhwc_weight_as_input_quant8();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nhwc_weight_as_input_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nchw) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nchw,
                           conv2d_v1_2::is_ignored_nchw,
                           conv2d_v1_2::get_examples_nchw());
}

TEST_F(ValidationTest, conv2d_v1_2_nchw) {
  const Model model = conv2d_v1_2::createTestModel_nchw();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nchw());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nchw_relaxed) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nchw_relaxed,
                           conv2d_v1_2::is_ignored_nchw_relaxed,
                           conv2d_v1_2::get_examples_nchw_relaxed());
}

TEST_F(ValidationTest, conv2d_v1_2_nchw_relaxed) {
  const Model model = conv2d_v1_2::createTestModel_nchw_relaxed();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nchw_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nchw_quant8) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nchw_quant8,
                           conv2d_v1_2::is_ignored_nchw_quant8,
                           conv2d_v1_2::get_examples_nchw_quant8());
}

TEST_F(ValidationTest, conv2d_v1_2_nchw_quant8) {
  const Model model = conv2d_v1_2::createTestModel_nchw_quant8();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nchw_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nchw_weight_as_input) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nchw_weight_as_input,
                           conv2d_v1_2::is_ignored_nchw_weight_as_input,
                           conv2d_v1_2::get_examples_nchw_weight_as_input());
}

TEST_F(ValidationTest, conv2d_v1_2_nchw_weight_as_input) {
  const Model model = conv2d_v1_2::createTestModel_nchw_weight_as_input();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nchw_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nchw_weight_as_input_relaxed) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nchw_weight_as_input_relaxed,
                           conv2d_v1_2::is_ignored_nchw_weight_as_input_relaxed,
                           conv2d_v1_2::get_examples_nchw_weight_as_input_relaxed());
}

TEST_F(ValidationTest, conv2d_v1_2_nchw_weight_as_input_relaxed) {
  const Model model = conv2d_v1_2::createTestModel_nchw_weight_as_input_relaxed();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nchw_weight_as_input_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nchw_weight_as_input_quant8) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nchw_weight_as_input_quant8,
                           conv2d_v1_2::is_ignored_nchw_weight_as_input_quant8,
                           conv2d_v1_2::get_examples_nchw_weight_as_input_quant8());
}

TEST_F(ValidationTest, conv2d_v1_2_nchw_weight_as_input_quant8) {
  const Model model = conv2d_v1_2::createTestModel_nchw_weight_as_input_quant8();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nchw_weight_as_input_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nhwc_2) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nhwc_2,
                           conv2d_v1_2::is_ignored_nhwc_2,
                           conv2d_v1_2::get_examples_nhwc_2());
}

TEST_F(ValidationTest, conv2d_v1_2_nhwc_2) {
  const Model model = conv2d_v1_2::createTestModel_nhwc_2();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nhwc_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nhwc_relaxed_2) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nhwc_relaxed_2,
                           conv2d_v1_2::is_ignored_nhwc_relaxed_2,
                           conv2d_v1_2::get_examples_nhwc_relaxed_2());
}

TEST_F(ValidationTest, conv2d_v1_2_nhwc_relaxed_2) {
  const Model model = conv2d_v1_2::createTestModel_nhwc_relaxed_2();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nhwc_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nhwc_quant8_2) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nhwc_quant8_2,
                           conv2d_v1_2::is_ignored_nhwc_quant8_2,
                           conv2d_v1_2::get_examples_nhwc_quant8_2());
}

TEST_F(ValidationTest, conv2d_v1_2_nhwc_quant8_2) {
  const Model model = conv2d_v1_2::createTestModel_nhwc_quant8_2();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nhwc_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nhwc_weight_as_input_2) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nhwc_weight_as_input_2,
                           conv2d_v1_2::is_ignored_nhwc_weight_as_input_2,
                           conv2d_v1_2::get_examples_nhwc_weight_as_input_2());
}

TEST_F(ValidationTest, conv2d_v1_2_nhwc_weight_as_input_2) {
  const Model model = conv2d_v1_2::createTestModel_nhwc_weight_as_input_2();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nhwc_weight_as_input_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nhwc_weight_as_input_relaxed_2) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nhwc_weight_as_input_relaxed_2,
                           conv2d_v1_2::is_ignored_nhwc_weight_as_input_relaxed_2,
                           conv2d_v1_2::get_examples_nhwc_weight_as_input_relaxed_2());
}

TEST_F(ValidationTest, conv2d_v1_2_nhwc_weight_as_input_relaxed_2) {
  const Model model = conv2d_v1_2::createTestModel_nhwc_weight_as_input_relaxed_2();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nhwc_weight_as_input_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nhwc_weight_as_input_quant8_2) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nhwc_weight_as_input_quant8_2,
                           conv2d_v1_2::is_ignored_nhwc_weight_as_input_quant8_2,
                           conv2d_v1_2::get_examples_nhwc_weight_as_input_quant8_2());
}

TEST_F(ValidationTest, conv2d_v1_2_nhwc_weight_as_input_quant8_2) {
  const Model model = conv2d_v1_2::createTestModel_nhwc_weight_as_input_quant8_2();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nhwc_weight_as_input_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nchw_2) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nchw_2,
                           conv2d_v1_2::is_ignored_nchw_2,
                           conv2d_v1_2::get_examples_nchw_2());
}

TEST_F(ValidationTest, conv2d_v1_2_nchw_2) {
  const Model model = conv2d_v1_2::createTestModel_nchw_2();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nchw_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nchw_relaxed_2) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nchw_relaxed_2,
                           conv2d_v1_2::is_ignored_nchw_relaxed_2,
                           conv2d_v1_2::get_examples_nchw_relaxed_2());
}

TEST_F(ValidationTest, conv2d_v1_2_nchw_relaxed_2) {
  const Model model = conv2d_v1_2::createTestModel_nchw_relaxed_2();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nchw_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nchw_quant8_2) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nchw_quant8_2,
                           conv2d_v1_2::is_ignored_nchw_quant8_2,
                           conv2d_v1_2::get_examples_nchw_quant8_2());
}

TEST_F(ValidationTest, conv2d_v1_2_nchw_quant8_2) {
  const Model model = conv2d_v1_2::createTestModel_nchw_quant8_2();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nchw_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nchw_weight_as_input_2) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nchw_weight_as_input_2,
                           conv2d_v1_2::is_ignored_nchw_weight_as_input_2,
                           conv2d_v1_2::get_examples_nchw_weight_as_input_2());
}

TEST_F(ValidationTest, conv2d_v1_2_nchw_weight_as_input_2) {
  const Model model = conv2d_v1_2::createTestModel_nchw_weight_as_input_2();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nchw_weight_as_input_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nchw_weight_as_input_relaxed_2) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nchw_weight_as_input_relaxed_2,
                           conv2d_v1_2::is_ignored_nchw_weight_as_input_relaxed_2,
                           conv2d_v1_2::get_examples_nchw_weight_as_input_relaxed_2());
}

TEST_F(ValidationTest, conv2d_v1_2_nchw_weight_as_input_relaxed_2) {
  const Model model = conv2d_v1_2::createTestModel_nchw_weight_as_input_relaxed_2();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nchw_weight_as_input_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_nchw_weight_as_input_quant8_2) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_nchw_weight_as_input_quant8_2,
                           conv2d_v1_2::is_ignored_nchw_weight_as_input_quant8_2,
                           conv2d_v1_2::get_examples_nchw_weight_as_input_quant8_2());
}

TEST_F(ValidationTest, conv2d_v1_2_nchw_weight_as_input_quant8_2) {
  const Model model = conv2d_v1_2::createTestModel_nchw_weight_as_input_quant8_2();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_nchw_weight_as_input_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_channel_nhwc) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_channel_nhwc,
                           conv2d_v1_2::is_ignored_channel_nhwc,
                           conv2d_v1_2::get_examples_channel_nhwc());
}

TEST_F(ValidationTest, conv2d_v1_2_channel_nhwc) {
  const Model model = conv2d_v1_2::createTestModel_channel_nhwc();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_channel_nhwc());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_channel_nhwc_relaxed) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_channel_nhwc_relaxed,
                           conv2d_v1_2::is_ignored_channel_nhwc_relaxed,
                           conv2d_v1_2::get_examples_channel_nhwc_relaxed());
}

TEST_F(ValidationTest, conv2d_v1_2_channel_nhwc_relaxed) {
  const Model model = conv2d_v1_2::createTestModel_channel_nhwc_relaxed();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_channel_nhwc_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_channel_nhwc_quant8) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_channel_nhwc_quant8,
                           conv2d_v1_2::is_ignored_channel_nhwc_quant8,
                           conv2d_v1_2::get_examples_channel_nhwc_quant8());
}

TEST_F(ValidationTest, conv2d_v1_2_channel_nhwc_quant8) {
  const Model model = conv2d_v1_2::createTestModel_channel_nhwc_quant8();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_channel_nhwc_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_channel_nhwc_weight_as_input) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_channel_nhwc_weight_as_input,
                           conv2d_v1_2::is_ignored_channel_nhwc_weight_as_input,
                           conv2d_v1_2::get_examples_channel_nhwc_weight_as_input());
}

TEST_F(ValidationTest, conv2d_v1_2_channel_nhwc_weight_as_input) {
  const Model model = conv2d_v1_2::createTestModel_channel_nhwc_weight_as_input();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_channel_nhwc_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_channel_nhwc_weight_as_input_relaxed) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_channel_nhwc_weight_as_input_relaxed,
                           conv2d_v1_2::is_ignored_channel_nhwc_weight_as_input_relaxed,
                           conv2d_v1_2::get_examples_channel_nhwc_weight_as_input_relaxed());
}

TEST_F(ValidationTest, conv2d_v1_2_channel_nhwc_weight_as_input_relaxed) {
  const Model model = conv2d_v1_2::createTestModel_channel_nhwc_weight_as_input_relaxed();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_channel_nhwc_weight_as_input_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_channel_nhwc_weight_as_input_quant8) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_channel_nhwc_weight_as_input_quant8,
                           conv2d_v1_2::is_ignored_channel_nhwc_weight_as_input_quant8,
                           conv2d_v1_2::get_examples_channel_nhwc_weight_as_input_quant8());
}

TEST_F(ValidationTest, conv2d_v1_2_channel_nhwc_weight_as_input_quant8) {
  const Model model = conv2d_v1_2::createTestModel_channel_nhwc_weight_as_input_quant8();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_channel_nhwc_weight_as_input_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_channel_nchw) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_channel_nchw,
                           conv2d_v1_2::is_ignored_channel_nchw,
                           conv2d_v1_2::get_examples_channel_nchw());
}

TEST_F(ValidationTest, conv2d_v1_2_channel_nchw) {
  const Model model = conv2d_v1_2::createTestModel_channel_nchw();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_channel_nchw());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_channel_nchw_relaxed) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_channel_nchw_relaxed,
                           conv2d_v1_2::is_ignored_channel_nchw_relaxed,
                           conv2d_v1_2::get_examples_channel_nchw_relaxed());
}

TEST_F(ValidationTest, conv2d_v1_2_channel_nchw_relaxed) {
  const Model model = conv2d_v1_2::createTestModel_channel_nchw_relaxed();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_channel_nchw_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_channel_nchw_quant8) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_channel_nchw_quant8,
                           conv2d_v1_2::is_ignored_channel_nchw_quant8,
                           conv2d_v1_2::get_examples_channel_nchw_quant8());
}

TEST_F(ValidationTest, conv2d_v1_2_channel_nchw_quant8) {
  const Model model = conv2d_v1_2::createTestModel_channel_nchw_quant8();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_channel_nchw_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_channel_nchw_weight_as_input) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_channel_nchw_weight_as_input,
                           conv2d_v1_2::is_ignored_channel_nchw_weight_as_input,
                           conv2d_v1_2::get_examples_channel_nchw_weight_as_input());
}

TEST_F(ValidationTest, conv2d_v1_2_channel_nchw_weight_as_input) {
  const Model model = conv2d_v1_2::createTestModel_channel_nchw_weight_as_input();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_channel_nchw_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_channel_nchw_weight_as_input_relaxed) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_channel_nchw_weight_as_input_relaxed,
                           conv2d_v1_2::is_ignored_channel_nchw_weight_as_input_relaxed,
                           conv2d_v1_2::get_examples_channel_nchw_weight_as_input_relaxed());
}

TEST_F(ValidationTest, conv2d_v1_2_channel_nchw_weight_as_input_relaxed) {
  const Model model = conv2d_v1_2::createTestModel_channel_nchw_weight_as_input_relaxed();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_channel_nchw_weight_as_input_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_channel_nchw_weight_as_input_quant8) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_channel_nchw_weight_as_input_quant8,
                           conv2d_v1_2::is_ignored_channel_nchw_weight_as_input_quant8,
                           conv2d_v1_2::get_examples_channel_nchw_weight_as_input_quant8());
}

TEST_F(ValidationTest, conv2d_v1_2_channel_nchw_weight_as_input_quant8) {
  const Model model = conv2d_v1_2::createTestModel_channel_nchw_weight_as_input_quant8();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_channel_nchw_weight_as_input_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_large_nhwc) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_large_nhwc,
                           conv2d_v1_2::is_ignored_large_nhwc,
                           conv2d_v1_2::get_examples_large_nhwc());
}

TEST_F(ValidationTest, conv2d_v1_2_large_nhwc) {
  const Model model = conv2d_v1_2::createTestModel_large_nhwc();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_large_nhwc());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_large_nhwc_relaxed) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_large_nhwc_relaxed,
                           conv2d_v1_2::is_ignored_large_nhwc_relaxed,
                           conv2d_v1_2::get_examples_large_nhwc_relaxed());
}

TEST_F(ValidationTest, conv2d_v1_2_large_nhwc_relaxed) {
  const Model model = conv2d_v1_2::createTestModel_large_nhwc_relaxed();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_large_nhwc_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_large_nhwc_quant8) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_large_nhwc_quant8,
                           conv2d_v1_2::is_ignored_large_nhwc_quant8,
                           conv2d_v1_2::get_examples_large_nhwc_quant8());
}

TEST_F(ValidationTest, conv2d_v1_2_large_nhwc_quant8) {
  const Model model = conv2d_v1_2::createTestModel_large_nhwc_quant8();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_large_nhwc_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_large_nhwc_weight_as_input) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_large_nhwc_weight_as_input,
                           conv2d_v1_2::is_ignored_large_nhwc_weight_as_input,
                           conv2d_v1_2::get_examples_large_nhwc_weight_as_input());
}

TEST_F(ValidationTest, conv2d_v1_2_large_nhwc_weight_as_input) {
  const Model model = conv2d_v1_2::createTestModel_large_nhwc_weight_as_input();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_large_nhwc_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_large_nhwc_weight_as_input_relaxed) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_large_nhwc_weight_as_input_relaxed,
                           conv2d_v1_2::is_ignored_large_nhwc_weight_as_input_relaxed,
                           conv2d_v1_2::get_examples_large_nhwc_weight_as_input_relaxed());
}

TEST_F(ValidationTest, conv2d_v1_2_large_nhwc_weight_as_input_relaxed) {
  const Model model = conv2d_v1_2::createTestModel_large_nhwc_weight_as_input_relaxed();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_large_nhwc_weight_as_input_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_large_nhwc_weight_as_input_quant8) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_large_nhwc_weight_as_input_quant8,
                           conv2d_v1_2::is_ignored_large_nhwc_weight_as_input_quant8,
                           conv2d_v1_2::get_examples_large_nhwc_weight_as_input_quant8());
}

TEST_F(ValidationTest, conv2d_v1_2_large_nhwc_weight_as_input_quant8) {
  const Model model = conv2d_v1_2::createTestModel_large_nhwc_weight_as_input_quant8();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_large_nhwc_weight_as_input_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_large_nchw) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_large_nchw,
                           conv2d_v1_2::is_ignored_large_nchw,
                           conv2d_v1_2::get_examples_large_nchw());
}

TEST_F(ValidationTest, conv2d_v1_2_large_nchw) {
  const Model model = conv2d_v1_2::createTestModel_large_nchw();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_large_nchw());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_large_nchw_relaxed) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_large_nchw_relaxed,
                           conv2d_v1_2::is_ignored_large_nchw_relaxed,
                           conv2d_v1_2::get_examples_large_nchw_relaxed());
}

TEST_F(ValidationTest, conv2d_v1_2_large_nchw_relaxed) {
  const Model model = conv2d_v1_2::createTestModel_large_nchw_relaxed();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_large_nchw_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_large_nchw_quant8) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_large_nchw_quant8,
                           conv2d_v1_2::is_ignored_large_nchw_quant8,
                           conv2d_v1_2::get_examples_large_nchw_quant8());
}

TEST_F(ValidationTest, conv2d_v1_2_large_nchw_quant8) {
  const Model model = conv2d_v1_2::createTestModel_large_nchw_quant8();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_large_nchw_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_large_nchw_weight_as_input) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_large_nchw_weight_as_input,
                           conv2d_v1_2::is_ignored_large_nchw_weight_as_input,
                           conv2d_v1_2::get_examples_large_nchw_weight_as_input());
}

TEST_F(ValidationTest, conv2d_v1_2_large_nchw_weight_as_input) {
  const Model model = conv2d_v1_2::createTestModel_large_nchw_weight_as_input();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_large_nchw_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_large_nchw_weight_as_input_relaxed) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_large_nchw_weight_as_input_relaxed,
                           conv2d_v1_2::is_ignored_large_nchw_weight_as_input_relaxed,
                           conv2d_v1_2::get_examples_large_nchw_weight_as_input_relaxed());
}

TEST_F(ValidationTest, conv2d_v1_2_large_nchw_weight_as_input_relaxed) {
  const Model model = conv2d_v1_2::createTestModel_large_nchw_weight_as_input_relaxed();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_large_nchw_weight_as_input_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_large_nchw_weight_as_input_quant8) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_large_nchw_weight_as_input_quant8,
                           conv2d_v1_2::is_ignored_large_nchw_weight_as_input_quant8,
                           conv2d_v1_2::get_examples_large_nchw_weight_as_input_quant8());
}

TEST_F(ValidationTest, conv2d_v1_2_large_nchw_weight_as_input_quant8) {
  const Model model = conv2d_v1_2::createTestModel_large_nchw_weight_as_input_quant8();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_large_nchw_weight_as_input_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_1_H3_W2_SAME_nhwc) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_1_H3_W2_SAME_nhwc,
                           conv2d_v1_2::is_ignored_1_H3_W2_SAME_nhwc,
                           conv2d_v1_2::get_examples_1_H3_W2_SAME_nhwc());
}

TEST_F(ValidationTest, conv2d_v1_2_1_H3_W2_SAME_nhwc) {
  const Model model = conv2d_v1_2::createTestModel_1_H3_W2_SAME_nhwc();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_1_H3_W2_SAME_nhwc());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_1_H3_W2_SAME_nhwc_relaxed) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_1_H3_W2_SAME_nhwc_relaxed,
                           conv2d_v1_2::is_ignored_1_H3_W2_SAME_nhwc_relaxed,
                           conv2d_v1_2::get_examples_1_H3_W2_SAME_nhwc_relaxed());
}

TEST_F(ValidationTest, conv2d_v1_2_1_H3_W2_SAME_nhwc_relaxed) {
  const Model model = conv2d_v1_2::createTestModel_1_H3_W2_SAME_nhwc_relaxed();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_1_H3_W2_SAME_nhwc_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_1_H3_W2_SAME_nchw) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_1_H3_W2_SAME_nchw,
                           conv2d_v1_2::is_ignored_1_H3_W2_SAME_nchw,
                           conv2d_v1_2::get_examples_1_H3_W2_SAME_nchw());
}

TEST_F(ValidationTest, conv2d_v1_2_1_H3_W2_SAME_nchw) {
  const Model model = conv2d_v1_2::createTestModel_1_H3_W2_SAME_nchw();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_1_H3_W2_SAME_nchw());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_1_H3_W2_SAME_nchw_relaxed) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_1_H3_W2_SAME_nchw_relaxed,
                           conv2d_v1_2::is_ignored_1_H3_W2_SAME_nchw_relaxed,
                           conv2d_v1_2::get_examples_1_H3_W2_SAME_nchw_relaxed());
}

TEST_F(ValidationTest, conv2d_v1_2_1_H3_W2_SAME_nchw_relaxed) {
  const Model model = conv2d_v1_2::createTestModel_1_H3_W2_SAME_nchw_relaxed();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_1_H3_W2_SAME_nchw_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_1_H3_W2_VALID_nhwc) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_1_H3_W2_VALID_nhwc,
                           conv2d_v1_2::is_ignored_1_H3_W2_VALID_nhwc,
                           conv2d_v1_2::get_examples_1_H3_W2_VALID_nhwc());
}

TEST_F(ValidationTest, conv2d_v1_2_1_H3_W2_VALID_nhwc) {
  const Model model = conv2d_v1_2::createTestModel_1_H3_W2_VALID_nhwc();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_1_H3_W2_VALID_nhwc());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_1_H3_W2_VALID_nhwc_relaxed) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_1_H3_W2_VALID_nhwc_relaxed,
                           conv2d_v1_2::is_ignored_1_H3_W2_VALID_nhwc_relaxed,
                           conv2d_v1_2::get_examples_1_H3_W2_VALID_nhwc_relaxed());
}

TEST_F(ValidationTest, conv2d_v1_2_1_H3_W2_VALID_nhwc_relaxed) {
  const Model model = conv2d_v1_2::createTestModel_1_H3_W2_VALID_nhwc_relaxed();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_1_H3_W2_VALID_nhwc_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_1_H3_W2_VALID_nchw) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_1_H3_W2_VALID_nchw,
                           conv2d_v1_2::is_ignored_1_H3_W2_VALID_nchw,
                           conv2d_v1_2::get_examples_1_H3_W2_VALID_nchw());
}

TEST_F(ValidationTest, conv2d_v1_2_1_H3_W2_VALID_nchw) {
  const Model model = conv2d_v1_2::createTestModel_1_H3_W2_VALID_nchw();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_1_H3_W2_VALID_nchw());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_1_H3_W2_VALID_nchw_relaxed) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_1_H3_W2_VALID_nchw_relaxed,
                           conv2d_v1_2::is_ignored_1_H3_W2_VALID_nchw_relaxed,
                           conv2d_v1_2::get_examples_1_H3_W2_VALID_nchw_relaxed());
}

TEST_F(ValidationTest, conv2d_v1_2_1_H3_W2_VALID_nchw_relaxed) {
  const Model model = conv2d_v1_2::createTestModel_1_H3_W2_VALID_nchw_relaxed();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_1_H3_W2_VALID_nchw_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_3_H3_W2_SAME_nhwc) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_3_H3_W2_SAME_nhwc,
                           conv2d_v1_2::is_ignored_3_H3_W2_SAME_nhwc,
                           conv2d_v1_2::get_examples_3_H3_W2_SAME_nhwc());
}

TEST_F(ValidationTest, conv2d_v1_2_3_H3_W2_SAME_nhwc) {
  const Model model = conv2d_v1_2::createTestModel_3_H3_W2_SAME_nhwc();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_3_H3_W2_SAME_nhwc());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_3_H3_W2_SAME_nhwc_relaxed) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_3_H3_W2_SAME_nhwc_relaxed,
                           conv2d_v1_2::is_ignored_3_H3_W2_SAME_nhwc_relaxed,
                           conv2d_v1_2::get_examples_3_H3_W2_SAME_nhwc_relaxed());
}

TEST_F(ValidationTest, conv2d_v1_2_3_H3_W2_SAME_nhwc_relaxed) {
  const Model model = conv2d_v1_2::createTestModel_3_H3_W2_SAME_nhwc_relaxed();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_3_H3_W2_SAME_nhwc_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_3_H3_W2_SAME_nchw) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_3_H3_W2_SAME_nchw,
                           conv2d_v1_2::is_ignored_3_H3_W2_SAME_nchw,
                           conv2d_v1_2::get_examples_3_H3_W2_SAME_nchw());
}

TEST_F(ValidationTest, conv2d_v1_2_3_H3_W2_SAME_nchw) {
  const Model model = conv2d_v1_2::createTestModel_3_H3_W2_SAME_nchw();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_3_H3_W2_SAME_nchw());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_3_H3_W2_SAME_nchw_relaxed) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_3_H3_W2_SAME_nchw_relaxed,
                           conv2d_v1_2::is_ignored_3_H3_W2_SAME_nchw_relaxed,
                           conv2d_v1_2::get_examples_3_H3_W2_SAME_nchw_relaxed());
}

TEST_F(ValidationTest, conv2d_v1_2_3_H3_W2_SAME_nchw_relaxed) {
  const Model model = conv2d_v1_2::createTestModel_3_H3_W2_SAME_nchw_relaxed();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_3_H3_W2_SAME_nchw_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_3_H3_W2_VALID_nhwc) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_3_H3_W2_VALID_nhwc,
                           conv2d_v1_2::is_ignored_3_H3_W2_VALID_nhwc,
                           conv2d_v1_2::get_examples_3_H3_W2_VALID_nhwc());
}

TEST_F(ValidationTest, conv2d_v1_2_3_H3_W2_VALID_nhwc) {
  const Model model = conv2d_v1_2::createTestModel_3_H3_W2_VALID_nhwc();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_3_H3_W2_VALID_nhwc());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_3_H3_W2_VALID_nhwc_relaxed) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_3_H3_W2_VALID_nhwc_relaxed,
                           conv2d_v1_2::is_ignored_3_H3_W2_VALID_nhwc_relaxed,
                           conv2d_v1_2::get_examples_3_H3_W2_VALID_nhwc_relaxed());
}

TEST_F(ValidationTest, conv2d_v1_2_3_H3_W2_VALID_nhwc_relaxed) {
  const Model model = conv2d_v1_2::createTestModel_3_H3_W2_VALID_nhwc_relaxed();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_3_H3_W2_VALID_nhwc_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_3_H3_W2_VALID_nchw) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_3_H3_W2_VALID_nchw,
                           conv2d_v1_2::is_ignored_3_H3_W2_VALID_nchw,
                           conv2d_v1_2::get_examples_3_H3_W2_VALID_nchw());
}

TEST_F(ValidationTest, conv2d_v1_2_3_H3_W2_VALID_nchw) {
  const Model model = conv2d_v1_2::createTestModel_3_H3_W2_VALID_nchw();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_3_H3_W2_VALID_nchw());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, conv2d_v1_2_3_H3_W2_VALID_nchw_relaxed) {
  generated_tests::Execute(device,
                           conv2d_v1_2::createTestModel_3_H3_W2_VALID_nchw_relaxed,
                           conv2d_v1_2::is_ignored_3_H3_W2_VALID_nchw_relaxed,
                           conv2d_v1_2::get_examples_3_H3_W2_VALID_nchw_relaxed());
}

TEST_F(ValidationTest, conv2d_v1_2_3_H3_W2_VALID_nchw_relaxed) {
  const Model model = conv2d_v1_2::createTestModel_3_H3_W2_VALID_nchw_relaxed();
  const std::vector<Request> requests = createRequests(conv2d_v1_2::get_examples_3_H3_W2_VALID_nchw_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: depth_to_space_v1_2.mod.py.
namespace depth_to_space_v1_2 {
// Generated depth_to_space_v1_2 test
#include "examples/depth_to_space_v1_2.example.cpp"
// Generated model constructor
#include "vts_models/depth_to_space_v1_2.model.cpp"
} // namespace depth_to_space_v1_2

TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nhwc) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nhwc,
                           depth_to_space_v1_2::is_ignored_nhwc,
                           depth_to_space_v1_2::get_examples_nhwc());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nhwc) {
  const Model model = depth_to_space_v1_2::createTestModel_nhwc();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nhwc());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nhwc_relaxed) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nhwc_relaxed,
                           depth_to_space_v1_2::is_ignored_nhwc_relaxed,
                           depth_to_space_v1_2::get_examples_nhwc_relaxed());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nhwc_relaxed) {
  const Model model = depth_to_space_v1_2::createTestModel_nhwc_relaxed();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nhwc_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nhwc_float16) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nhwc_float16,
                           depth_to_space_v1_2::is_ignored_nhwc_float16,
                           depth_to_space_v1_2::get_examples_nhwc_float16());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nhwc_float16) {
  const Model model = depth_to_space_v1_2::createTestModel_nhwc_float16();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nhwc_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nhwc_quant8) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nhwc_quant8,
                           depth_to_space_v1_2::is_ignored_nhwc_quant8,
                           depth_to_space_v1_2::get_examples_nhwc_quant8());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nhwc_quant8) {
  const Model model = depth_to_space_v1_2::createTestModel_nhwc_quant8();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nhwc_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nchw) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nchw,
                           depth_to_space_v1_2::is_ignored_nchw,
                           depth_to_space_v1_2::get_examples_nchw());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nchw) {
  const Model model = depth_to_space_v1_2::createTestModel_nchw();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nchw());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nchw_relaxed) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nchw_relaxed,
                           depth_to_space_v1_2::is_ignored_nchw_relaxed,
                           depth_to_space_v1_2::get_examples_nchw_relaxed());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nchw_relaxed) {
  const Model model = depth_to_space_v1_2::createTestModel_nchw_relaxed();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nchw_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nchw_float16) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nchw_float16,
                           depth_to_space_v1_2::is_ignored_nchw_float16,
                           depth_to_space_v1_2::get_examples_nchw_float16());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nchw_float16) {
  const Model model = depth_to_space_v1_2::createTestModel_nchw_float16();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nchw_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nchw_quant8) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nchw_quant8,
                           depth_to_space_v1_2::is_ignored_nchw_quant8,
                           depth_to_space_v1_2::get_examples_nchw_quant8());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nchw_quant8) {
  const Model model = depth_to_space_v1_2::createTestModel_nchw_quant8();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nchw_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nhwc_2) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nhwc_2,
                           depth_to_space_v1_2::is_ignored_nhwc_2,
                           depth_to_space_v1_2::get_examples_nhwc_2());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nhwc_2) {
  const Model model = depth_to_space_v1_2::createTestModel_nhwc_2();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nhwc_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nhwc_relaxed_2) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nhwc_relaxed_2,
                           depth_to_space_v1_2::is_ignored_nhwc_relaxed_2,
                           depth_to_space_v1_2::get_examples_nhwc_relaxed_2());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nhwc_relaxed_2) {
  const Model model = depth_to_space_v1_2::createTestModel_nhwc_relaxed_2();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nhwc_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nhwc_float16_2) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nhwc_float16_2,
                           depth_to_space_v1_2::is_ignored_nhwc_float16_2,
                           depth_to_space_v1_2::get_examples_nhwc_float16_2());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nhwc_float16_2) {
  const Model model = depth_to_space_v1_2::createTestModel_nhwc_float16_2();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nhwc_float16_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nhwc_quant8_2) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nhwc_quant8_2,
                           depth_to_space_v1_2::is_ignored_nhwc_quant8_2,
                           depth_to_space_v1_2::get_examples_nhwc_quant8_2());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nhwc_quant8_2) {
  const Model model = depth_to_space_v1_2::createTestModel_nhwc_quant8_2();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nhwc_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nchw_2) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nchw_2,
                           depth_to_space_v1_2::is_ignored_nchw_2,
                           depth_to_space_v1_2::get_examples_nchw_2());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nchw_2) {
  const Model model = depth_to_space_v1_2::createTestModel_nchw_2();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nchw_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nchw_relaxed_2) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nchw_relaxed_2,
                           depth_to_space_v1_2::is_ignored_nchw_relaxed_2,
                           depth_to_space_v1_2::get_examples_nchw_relaxed_2());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nchw_relaxed_2) {
  const Model model = depth_to_space_v1_2::createTestModel_nchw_relaxed_2();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nchw_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nchw_float16_2) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nchw_float16_2,
                           depth_to_space_v1_2::is_ignored_nchw_float16_2,
                           depth_to_space_v1_2::get_examples_nchw_float16_2());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nchw_float16_2) {
  const Model model = depth_to_space_v1_2::createTestModel_nchw_float16_2();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nchw_float16_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nchw_quant8_2) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nchw_quant8_2,
                           depth_to_space_v1_2::is_ignored_nchw_quant8_2,
                           depth_to_space_v1_2::get_examples_nchw_quant8_2());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nchw_quant8_2) {
  const Model model = depth_to_space_v1_2::createTestModel_nchw_quant8_2();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nchw_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nhwc_3) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nhwc_3,
                           depth_to_space_v1_2::is_ignored_nhwc_3,
                           depth_to_space_v1_2::get_examples_nhwc_3());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nhwc_3) {
  const Model model = depth_to_space_v1_2::createTestModel_nhwc_3();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nhwc_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nhwc_relaxed_3) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nhwc_relaxed_3,
                           depth_to_space_v1_2::is_ignored_nhwc_relaxed_3,
                           depth_to_space_v1_2::get_examples_nhwc_relaxed_3());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nhwc_relaxed_3) {
  const Model model = depth_to_space_v1_2::createTestModel_nhwc_relaxed_3();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nhwc_relaxed_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nhwc_float16_3) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nhwc_float16_3,
                           depth_to_space_v1_2::is_ignored_nhwc_float16_3,
                           depth_to_space_v1_2::get_examples_nhwc_float16_3());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nhwc_float16_3) {
  const Model model = depth_to_space_v1_2::createTestModel_nhwc_float16_3();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nhwc_float16_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nhwc_quant8_3) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nhwc_quant8_3,
                           depth_to_space_v1_2::is_ignored_nhwc_quant8_3,
                           depth_to_space_v1_2::get_examples_nhwc_quant8_3());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nhwc_quant8_3) {
  const Model model = depth_to_space_v1_2::createTestModel_nhwc_quant8_3();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nhwc_quant8_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nchw_3) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nchw_3,
                           depth_to_space_v1_2::is_ignored_nchw_3,
                           depth_to_space_v1_2::get_examples_nchw_3());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nchw_3) {
  const Model model = depth_to_space_v1_2::createTestModel_nchw_3();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nchw_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nchw_relaxed_3) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nchw_relaxed_3,
                           depth_to_space_v1_2::is_ignored_nchw_relaxed_3,
                           depth_to_space_v1_2::get_examples_nchw_relaxed_3());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nchw_relaxed_3) {
  const Model model = depth_to_space_v1_2::createTestModel_nchw_relaxed_3();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nchw_relaxed_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nchw_float16_3) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nchw_float16_3,
                           depth_to_space_v1_2::is_ignored_nchw_float16_3,
                           depth_to_space_v1_2::get_examples_nchw_float16_3());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nchw_float16_3) {
  const Model model = depth_to_space_v1_2::createTestModel_nchw_float16_3();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nchw_float16_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depth_to_space_v1_2_nchw_quant8_3) {
  generated_tests::Execute(device,
                           depth_to_space_v1_2::createTestModel_nchw_quant8_3,
                           depth_to_space_v1_2::is_ignored_nchw_quant8_3,
                           depth_to_space_v1_2::get_examples_nchw_quant8_3());
}

TEST_F(ValidationTest, depth_to_space_v1_2_nchw_quant8_3) {
  const Model model = depth_to_space_v1_2::createTestModel_nchw_quant8_3();
  const std::vector<Request> requests = createRequests(depth_to_space_v1_2::get_examples_nchw_quant8_3());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: depthwise_conv2d_v1_2.mod.py.
namespace depthwise_conv2d_v1_2 {
// Generated depthwise_conv2d_v1_2 test
#include "examples/depthwise_conv2d_v1_2.example.cpp"
// Generated model constructor
#include "vts_models/depthwise_conv2d_v1_2.model.cpp"
} // namespace depthwise_conv2d_v1_2

TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nhwc) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nhwc,
                           depthwise_conv2d_v1_2::is_ignored_nhwc,
                           depthwise_conv2d_v1_2::get_examples_nhwc());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nhwc) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nhwc();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nhwc());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nhwc_relaxed) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nhwc_relaxed,
                           depthwise_conv2d_v1_2::is_ignored_nhwc_relaxed,
                           depthwise_conv2d_v1_2::get_examples_nhwc_relaxed());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nhwc_relaxed) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nhwc_relaxed();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nhwc_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nhwc_float16) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nhwc_float16,
                           depthwise_conv2d_v1_2::is_ignored_nhwc_float16,
                           depthwise_conv2d_v1_2::get_examples_nhwc_float16());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nhwc_float16) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nhwc_float16();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nhwc_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nhwc_quant8) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nhwc_quant8,
                           depthwise_conv2d_v1_2::is_ignored_nhwc_quant8,
                           depthwise_conv2d_v1_2::get_examples_nhwc_quant8());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nhwc_quant8) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nhwc_quant8();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nhwc_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nhwc_weight_as_input) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nhwc_weight_as_input,
                           depthwise_conv2d_v1_2::is_ignored_nhwc_weight_as_input,
                           depthwise_conv2d_v1_2::get_examples_nhwc_weight_as_input());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nhwc_weight_as_input) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nhwc_weight_as_input();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nhwc_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nhwc_weight_as_input_relaxed) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nhwc_weight_as_input_relaxed,
                           depthwise_conv2d_v1_2::is_ignored_nhwc_weight_as_input_relaxed,
                           depthwise_conv2d_v1_2::get_examples_nhwc_weight_as_input_relaxed());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nhwc_weight_as_input_relaxed) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nhwc_weight_as_input_relaxed();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nhwc_weight_as_input_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nhwc_weight_as_input_float16) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nhwc_weight_as_input_float16,
                           depthwise_conv2d_v1_2::is_ignored_nhwc_weight_as_input_float16,
                           depthwise_conv2d_v1_2::get_examples_nhwc_weight_as_input_float16());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nhwc_weight_as_input_float16) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nhwc_weight_as_input_float16();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nhwc_weight_as_input_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nhwc_weight_as_input_quant8) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nhwc_weight_as_input_quant8,
                           depthwise_conv2d_v1_2::is_ignored_nhwc_weight_as_input_quant8,
                           depthwise_conv2d_v1_2::get_examples_nhwc_weight_as_input_quant8());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nhwc_weight_as_input_quant8) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nhwc_weight_as_input_quant8();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nhwc_weight_as_input_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nchw) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nchw,
                           depthwise_conv2d_v1_2::is_ignored_nchw,
                           depthwise_conv2d_v1_2::get_examples_nchw());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nchw) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nchw();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nchw());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nchw_relaxed) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nchw_relaxed,
                           depthwise_conv2d_v1_2::is_ignored_nchw_relaxed,
                           depthwise_conv2d_v1_2::get_examples_nchw_relaxed());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nchw_relaxed) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nchw_relaxed();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nchw_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nchw_float16) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nchw_float16,
                           depthwise_conv2d_v1_2::is_ignored_nchw_float16,
                           depthwise_conv2d_v1_2::get_examples_nchw_float16());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nchw_float16) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nchw_float16();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nchw_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nchw_quant8) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nchw_quant8,
                           depthwise_conv2d_v1_2::is_ignored_nchw_quant8,
                           depthwise_conv2d_v1_2::get_examples_nchw_quant8());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nchw_quant8) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nchw_quant8();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nchw_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nchw_weight_as_input) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nchw_weight_as_input,
                           depthwise_conv2d_v1_2::is_ignored_nchw_weight_as_input,
                           depthwise_conv2d_v1_2::get_examples_nchw_weight_as_input());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nchw_weight_as_input) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nchw_weight_as_input();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nchw_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nchw_weight_as_input_relaxed) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nchw_weight_as_input_relaxed,
                           depthwise_conv2d_v1_2::is_ignored_nchw_weight_as_input_relaxed,
                           depthwise_conv2d_v1_2::get_examples_nchw_weight_as_input_relaxed());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nchw_weight_as_input_relaxed) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nchw_weight_as_input_relaxed();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nchw_weight_as_input_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nchw_weight_as_input_float16) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nchw_weight_as_input_float16,
                           depthwise_conv2d_v1_2::is_ignored_nchw_weight_as_input_float16,
                           depthwise_conv2d_v1_2::get_examples_nchw_weight_as_input_float16());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nchw_weight_as_input_float16) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nchw_weight_as_input_float16();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nchw_weight_as_input_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nchw_weight_as_input_quant8) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nchw_weight_as_input_quant8,
                           depthwise_conv2d_v1_2::is_ignored_nchw_weight_as_input_quant8,
                           depthwise_conv2d_v1_2::get_examples_nchw_weight_as_input_quant8());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nchw_weight_as_input_quant8) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nchw_weight_as_input_quant8();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nchw_weight_as_input_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nhwc_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nhwc_2,
                           depthwise_conv2d_v1_2::is_ignored_nhwc_2,
                           depthwise_conv2d_v1_2::get_examples_nhwc_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nhwc_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nhwc_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nhwc_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nhwc_relaxed_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nhwc_relaxed_2,
                           depthwise_conv2d_v1_2::is_ignored_nhwc_relaxed_2,
                           depthwise_conv2d_v1_2::get_examples_nhwc_relaxed_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nhwc_relaxed_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nhwc_relaxed_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nhwc_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nhwc_float16_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nhwc_float16_2,
                           depthwise_conv2d_v1_2::is_ignored_nhwc_float16_2,
                           depthwise_conv2d_v1_2::get_examples_nhwc_float16_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nhwc_float16_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nhwc_float16_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nhwc_float16_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nhwc_quant8_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nhwc_quant8_2,
                           depthwise_conv2d_v1_2::is_ignored_nhwc_quant8_2,
                           depthwise_conv2d_v1_2::get_examples_nhwc_quant8_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nhwc_quant8_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nhwc_quant8_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nhwc_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nhwc_weight_as_input_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nhwc_weight_as_input_2,
                           depthwise_conv2d_v1_2::is_ignored_nhwc_weight_as_input_2,
                           depthwise_conv2d_v1_2::get_examples_nhwc_weight_as_input_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nhwc_weight_as_input_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nhwc_weight_as_input_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nhwc_weight_as_input_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nhwc_weight_as_input_relaxed_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nhwc_weight_as_input_relaxed_2,
                           depthwise_conv2d_v1_2::is_ignored_nhwc_weight_as_input_relaxed_2,
                           depthwise_conv2d_v1_2::get_examples_nhwc_weight_as_input_relaxed_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nhwc_weight_as_input_relaxed_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nhwc_weight_as_input_relaxed_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nhwc_weight_as_input_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nhwc_weight_as_input_float16_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nhwc_weight_as_input_float16_2,
                           depthwise_conv2d_v1_2::is_ignored_nhwc_weight_as_input_float16_2,
                           depthwise_conv2d_v1_2::get_examples_nhwc_weight_as_input_float16_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nhwc_weight_as_input_float16_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nhwc_weight_as_input_float16_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nhwc_weight_as_input_float16_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nhwc_weight_as_input_quant8_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nhwc_weight_as_input_quant8_2,
                           depthwise_conv2d_v1_2::is_ignored_nhwc_weight_as_input_quant8_2,
                           depthwise_conv2d_v1_2::get_examples_nhwc_weight_as_input_quant8_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nhwc_weight_as_input_quant8_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nhwc_weight_as_input_quant8_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nhwc_weight_as_input_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nchw_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nchw_2,
                           depthwise_conv2d_v1_2::is_ignored_nchw_2,
                           depthwise_conv2d_v1_2::get_examples_nchw_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nchw_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nchw_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nchw_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nchw_relaxed_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nchw_relaxed_2,
                           depthwise_conv2d_v1_2::is_ignored_nchw_relaxed_2,
                           depthwise_conv2d_v1_2::get_examples_nchw_relaxed_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nchw_relaxed_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nchw_relaxed_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nchw_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nchw_float16_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nchw_float16_2,
                           depthwise_conv2d_v1_2::is_ignored_nchw_float16_2,
                           depthwise_conv2d_v1_2::get_examples_nchw_float16_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nchw_float16_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nchw_float16_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nchw_float16_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nchw_quant8_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nchw_quant8_2,
                           depthwise_conv2d_v1_2::is_ignored_nchw_quant8_2,
                           depthwise_conv2d_v1_2::get_examples_nchw_quant8_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nchw_quant8_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nchw_quant8_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nchw_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nchw_weight_as_input_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nchw_weight_as_input_2,
                           depthwise_conv2d_v1_2::is_ignored_nchw_weight_as_input_2,
                           depthwise_conv2d_v1_2::get_examples_nchw_weight_as_input_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nchw_weight_as_input_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nchw_weight_as_input_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nchw_weight_as_input_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nchw_weight_as_input_relaxed_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nchw_weight_as_input_relaxed_2,
                           depthwise_conv2d_v1_2::is_ignored_nchw_weight_as_input_relaxed_2,
                           depthwise_conv2d_v1_2::get_examples_nchw_weight_as_input_relaxed_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nchw_weight_as_input_relaxed_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nchw_weight_as_input_relaxed_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nchw_weight_as_input_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nchw_weight_as_input_float16_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nchw_weight_as_input_float16_2,
                           depthwise_conv2d_v1_2::is_ignored_nchw_weight_as_input_float16_2,
                           depthwise_conv2d_v1_2::get_examples_nchw_weight_as_input_float16_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nchw_weight_as_input_float16_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nchw_weight_as_input_float16_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nchw_weight_as_input_float16_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_nchw_weight_as_input_quant8_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_nchw_weight_as_input_quant8_2,
                           depthwise_conv2d_v1_2::is_ignored_nchw_weight_as_input_quant8_2,
                           depthwise_conv2d_v1_2::get_examples_nchw_weight_as_input_quant8_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_nchw_weight_as_input_quant8_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_nchw_weight_as_input_quant8_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_nchw_weight_as_input_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nhwc) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nhwc,
                           depthwise_conv2d_v1_2::is_ignored_large_nhwc,
                           depthwise_conv2d_v1_2::get_examples_large_nhwc());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nhwc) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nhwc();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nhwc());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nhwc_relaxed) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nhwc_relaxed,
                           depthwise_conv2d_v1_2::is_ignored_large_nhwc_relaxed,
                           depthwise_conv2d_v1_2::get_examples_large_nhwc_relaxed());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nhwc_relaxed) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nhwc_relaxed();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nhwc_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nhwc_float16) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nhwc_float16,
                           depthwise_conv2d_v1_2::is_ignored_large_nhwc_float16,
                           depthwise_conv2d_v1_2::get_examples_large_nhwc_float16());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nhwc_float16) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nhwc_float16();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nhwc_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nhwc_quant8) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nhwc_quant8,
                           depthwise_conv2d_v1_2::is_ignored_large_nhwc_quant8,
                           depthwise_conv2d_v1_2::get_examples_large_nhwc_quant8());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nhwc_quant8) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nhwc_quant8();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nhwc_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nhwc_weight_as_input) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nhwc_weight_as_input,
                           depthwise_conv2d_v1_2::is_ignored_large_nhwc_weight_as_input,
                           depthwise_conv2d_v1_2::get_examples_large_nhwc_weight_as_input());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nhwc_weight_as_input) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nhwc_weight_as_input();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nhwc_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nhwc_weight_as_input_relaxed) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nhwc_weight_as_input_relaxed,
                           depthwise_conv2d_v1_2::is_ignored_large_nhwc_weight_as_input_relaxed,
                           depthwise_conv2d_v1_2::get_examples_large_nhwc_weight_as_input_relaxed());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nhwc_weight_as_input_relaxed) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nhwc_weight_as_input_relaxed();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nhwc_weight_as_input_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nhwc_weight_as_input_float16) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nhwc_weight_as_input_float16,
                           depthwise_conv2d_v1_2::is_ignored_large_nhwc_weight_as_input_float16,
                           depthwise_conv2d_v1_2::get_examples_large_nhwc_weight_as_input_float16());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nhwc_weight_as_input_float16) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nhwc_weight_as_input_float16();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nhwc_weight_as_input_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nhwc_weight_as_input_quant8) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nhwc_weight_as_input_quant8,
                           depthwise_conv2d_v1_2::is_ignored_large_nhwc_weight_as_input_quant8,
                           depthwise_conv2d_v1_2::get_examples_large_nhwc_weight_as_input_quant8());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nhwc_weight_as_input_quant8) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nhwc_weight_as_input_quant8();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nhwc_weight_as_input_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nchw) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nchw,
                           depthwise_conv2d_v1_2::is_ignored_large_nchw,
                           depthwise_conv2d_v1_2::get_examples_large_nchw());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nchw) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nchw();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nchw());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nchw_relaxed) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nchw_relaxed,
                           depthwise_conv2d_v1_2::is_ignored_large_nchw_relaxed,
                           depthwise_conv2d_v1_2::get_examples_large_nchw_relaxed());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nchw_relaxed) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nchw_relaxed();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nchw_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nchw_float16) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nchw_float16,
                           depthwise_conv2d_v1_2::is_ignored_large_nchw_float16,
                           depthwise_conv2d_v1_2::get_examples_large_nchw_float16());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nchw_float16) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nchw_float16();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nchw_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nchw_quant8) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nchw_quant8,
                           depthwise_conv2d_v1_2::is_ignored_large_nchw_quant8,
                           depthwise_conv2d_v1_2::get_examples_large_nchw_quant8());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nchw_quant8) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nchw_quant8();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nchw_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nchw_weight_as_input) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nchw_weight_as_input,
                           depthwise_conv2d_v1_2::is_ignored_large_nchw_weight_as_input,
                           depthwise_conv2d_v1_2::get_examples_large_nchw_weight_as_input());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nchw_weight_as_input) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nchw_weight_as_input();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nchw_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nchw_weight_as_input_relaxed) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nchw_weight_as_input_relaxed,
                           depthwise_conv2d_v1_2::is_ignored_large_nchw_weight_as_input_relaxed,
                           depthwise_conv2d_v1_2::get_examples_large_nchw_weight_as_input_relaxed());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nchw_weight_as_input_relaxed) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nchw_weight_as_input_relaxed();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nchw_weight_as_input_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nchw_weight_as_input_float16) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nchw_weight_as_input_float16,
                           depthwise_conv2d_v1_2::is_ignored_large_nchw_weight_as_input_float16,
                           depthwise_conv2d_v1_2::get_examples_large_nchw_weight_as_input_float16());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nchw_weight_as_input_float16) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nchw_weight_as_input_float16();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nchw_weight_as_input_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nchw_weight_as_input_quant8) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nchw_weight_as_input_quant8,
                           depthwise_conv2d_v1_2::is_ignored_large_nchw_weight_as_input_quant8,
                           depthwise_conv2d_v1_2::get_examples_large_nchw_weight_as_input_quant8());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nchw_weight_as_input_quant8) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nchw_weight_as_input_quant8();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nchw_weight_as_input_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nhwc_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nhwc_2,
                           depthwise_conv2d_v1_2::is_ignored_large_nhwc_2,
                           depthwise_conv2d_v1_2::get_examples_large_nhwc_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nhwc_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nhwc_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nhwc_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nhwc_relaxed_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nhwc_relaxed_2,
                           depthwise_conv2d_v1_2::is_ignored_large_nhwc_relaxed_2,
                           depthwise_conv2d_v1_2::get_examples_large_nhwc_relaxed_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nhwc_relaxed_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nhwc_relaxed_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nhwc_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nhwc_float16_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nhwc_float16_2,
                           depthwise_conv2d_v1_2::is_ignored_large_nhwc_float16_2,
                           depthwise_conv2d_v1_2::get_examples_large_nhwc_float16_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nhwc_float16_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nhwc_float16_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nhwc_float16_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nhwc_quant8_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nhwc_quant8_2,
                           depthwise_conv2d_v1_2::is_ignored_large_nhwc_quant8_2,
                           depthwise_conv2d_v1_2::get_examples_large_nhwc_quant8_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nhwc_quant8_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nhwc_quant8_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nhwc_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nhwc_weight_as_input_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nhwc_weight_as_input_2,
                           depthwise_conv2d_v1_2::is_ignored_large_nhwc_weight_as_input_2,
                           depthwise_conv2d_v1_2::get_examples_large_nhwc_weight_as_input_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nhwc_weight_as_input_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nhwc_weight_as_input_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nhwc_weight_as_input_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nhwc_weight_as_input_relaxed_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nhwc_weight_as_input_relaxed_2,
                           depthwise_conv2d_v1_2::is_ignored_large_nhwc_weight_as_input_relaxed_2,
                           depthwise_conv2d_v1_2::get_examples_large_nhwc_weight_as_input_relaxed_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nhwc_weight_as_input_relaxed_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nhwc_weight_as_input_relaxed_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nhwc_weight_as_input_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nhwc_weight_as_input_float16_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nhwc_weight_as_input_float16_2,
                           depthwise_conv2d_v1_2::is_ignored_large_nhwc_weight_as_input_float16_2,
                           depthwise_conv2d_v1_2::get_examples_large_nhwc_weight_as_input_float16_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nhwc_weight_as_input_float16_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nhwc_weight_as_input_float16_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nhwc_weight_as_input_float16_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nhwc_weight_as_input_quant8_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nhwc_weight_as_input_quant8_2,
                           depthwise_conv2d_v1_2::is_ignored_large_nhwc_weight_as_input_quant8_2,
                           depthwise_conv2d_v1_2::get_examples_large_nhwc_weight_as_input_quant8_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nhwc_weight_as_input_quant8_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nhwc_weight_as_input_quant8_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nhwc_weight_as_input_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nchw_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nchw_2,
                           depthwise_conv2d_v1_2::is_ignored_large_nchw_2,
                           depthwise_conv2d_v1_2::get_examples_large_nchw_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nchw_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nchw_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nchw_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nchw_relaxed_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nchw_relaxed_2,
                           depthwise_conv2d_v1_2::is_ignored_large_nchw_relaxed_2,
                           depthwise_conv2d_v1_2::get_examples_large_nchw_relaxed_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nchw_relaxed_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nchw_relaxed_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nchw_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nchw_float16_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nchw_float16_2,
                           depthwise_conv2d_v1_2::is_ignored_large_nchw_float16_2,
                           depthwise_conv2d_v1_2::get_examples_large_nchw_float16_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nchw_float16_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nchw_float16_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nchw_float16_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nchw_quant8_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nchw_quant8_2,
                           depthwise_conv2d_v1_2::is_ignored_large_nchw_quant8_2,
                           depthwise_conv2d_v1_2::get_examples_large_nchw_quant8_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nchw_quant8_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nchw_quant8_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nchw_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nchw_weight_as_input_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nchw_weight_as_input_2,
                           depthwise_conv2d_v1_2::is_ignored_large_nchw_weight_as_input_2,
                           depthwise_conv2d_v1_2::get_examples_large_nchw_weight_as_input_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nchw_weight_as_input_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nchw_weight_as_input_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nchw_weight_as_input_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nchw_weight_as_input_relaxed_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nchw_weight_as_input_relaxed_2,
                           depthwise_conv2d_v1_2::is_ignored_large_nchw_weight_as_input_relaxed_2,
                           depthwise_conv2d_v1_2::get_examples_large_nchw_weight_as_input_relaxed_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nchw_weight_as_input_relaxed_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nchw_weight_as_input_relaxed_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nchw_weight_as_input_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nchw_weight_as_input_float16_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nchw_weight_as_input_float16_2,
                           depthwise_conv2d_v1_2::is_ignored_large_nchw_weight_as_input_float16_2,
                           depthwise_conv2d_v1_2::get_examples_large_nchw_weight_as_input_float16_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nchw_weight_as_input_float16_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nchw_weight_as_input_float16_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nchw_weight_as_input_float16_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, depthwise_conv2d_v1_2_large_nchw_weight_as_input_quant8_2) {
  generated_tests::Execute(device,
                           depthwise_conv2d_v1_2::createTestModel_large_nchw_weight_as_input_quant8_2,
                           depthwise_conv2d_v1_2::is_ignored_large_nchw_weight_as_input_quant8_2,
                           depthwise_conv2d_v1_2::get_examples_large_nchw_weight_as_input_quant8_2());
}

TEST_F(ValidationTest, depthwise_conv2d_v1_2_large_nchw_weight_as_input_quant8_2) {
  const Model model = depthwise_conv2d_v1_2::createTestModel_large_nchw_weight_as_input_quant8_2();
  const std::vector<Request> requests = createRequests(depthwise_conv2d_v1_2::get_examples_large_nchw_weight_as_input_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: div_broadcast_float16.mod.py.
namespace div_broadcast_float16 {
// Generated div_broadcast_float16 test
#include "examples/div_broadcast_float16.example.cpp"
// Generated model constructor
#include "vts_models/div_broadcast_float16.model.cpp"
} // namespace div_broadcast_float16

TEST_F(NeuralnetworksHidlTest, div_broadcast_float16) {
  generated_tests::Execute(device,
                           div_broadcast_float16::createTestModel,
                           div_broadcast_float16::is_ignored,
                           div_broadcast_float16::get_examples());
}

TEST_F(ValidationTest, div_broadcast_float16) {
  const Model model = div_broadcast_float16::createTestModel();
  const std::vector<Request> requests = createRequests(div_broadcast_float16::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: div_float16.mod.py.
namespace div_float16 {
// Generated div_float16 test
#include "examples/div_float16.example.cpp"
// Generated model constructor
#include "vts_models/div_float16.model.cpp"
} // namespace div_float16

TEST_F(NeuralnetworksHidlTest, div_float16) {
  generated_tests::Execute(device,
                           div_float16::createTestModel,
                           div_float16::is_ignored,
                           div_float16::get_examples());
}

TEST_F(ValidationTest, div_float16) {
  const Model model = div_float16::createTestModel();
  const std::vector<Request> requests = createRequests(div_float16::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: expand_dims.mod.py.
namespace expand_dims {
// Generated expand_dims test
#include "examples/expand_dims.example.cpp"
// Generated model constructor
#include "vts_models/expand_dims.model.cpp"
} // namespace expand_dims

TEST_F(NeuralnetworksHidlTest, expand_dims) {
  generated_tests::Execute(device,
                           expand_dims::createTestModel,
                           expand_dims::is_ignored,
                           expand_dims::get_examples());
}

TEST_F(ValidationTest, expand_dims) {
  const Model model = expand_dims::createTestModel();
  const std::vector<Request> requests = createRequests(expand_dims::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, expand_dims_relaxed) {
  generated_tests::Execute(device,
                           expand_dims::createTestModel_relaxed,
                           expand_dims::is_ignored_relaxed,
                           expand_dims::get_examples_relaxed());
}

TEST_F(ValidationTest, expand_dims_relaxed) {
  const Model model = expand_dims::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(expand_dims::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, expand_dims_quant8) {
  generated_tests::Execute(device,
                           expand_dims::createTestModel_quant8,
                           expand_dims::is_ignored_quant8,
                           expand_dims::get_examples_quant8());
}

TEST_F(ValidationTest, expand_dims_quant8) {
  const Model model = expand_dims::createTestModel_quant8();
  const std::vector<Request> requests = createRequests(expand_dims::get_examples_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, expand_dims_int32) {
  generated_tests::Execute(device,
                           expand_dims::createTestModel_int32,
                           expand_dims::is_ignored_int32,
                           expand_dims::get_examples_int32());
}

TEST_F(ValidationTest, expand_dims_int32) {
  const Model model = expand_dims::createTestModel_int32();
  const std::vector<Request> requests = createRequests(expand_dims::get_examples_int32());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, expand_dims_2) {
  generated_tests::Execute(device,
                           expand_dims::createTestModel_2,
                           expand_dims::is_ignored_2,
                           expand_dims::get_examples_2());
}

TEST_F(ValidationTest, expand_dims_2) {
  const Model model = expand_dims::createTestModel_2();
  const std::vector<Request> requests = createRequests(expand_dims::get_examples_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, expand_dims_relaxed_2) {
  generated_tests::Execute(device,
                           expand_dims::createTestModel_relaxed_2,
                           expand_dims::is_ignored_relaxed_2,
                           expand_dims::get_examples_relaxed_2());
}

TEST_F(ValidationTest, expand_dims_relaxed_2) {
  const Model model = expand_dims::createTestModel_relaxed_2();
  const std::vector<Request> requests = createRequests(expand_dims::get_examples_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, expand_dims_quant8_2) {
  generated_tests::Execute(device,
                           expand_dims::createTestModel_quant8_2,
                           expand_dims::is_ignored_quant8_2,
                           expand_dims::get_examples_quant8_2());
}

TEST_F(ValidationTest, expand_dims_quant8_2) {
  const Model model = expand_dims::createTestModel_quant8_2();
  const std::vector<Request> requests = createRequests(expand_dims::get_examples_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, expand_dims_int32_2) {
  generated_tests::Execute(device,
                           expand_dims::createTestModel_int32_2,
                           expand_dims::is_ignored_int32_2,
                           expand_dims::get_examples_int32_2());
}

TEST_F(ValidationTest, expand_dims_int32_2) {
  const Model model = expand_dims::createTestModel_int32_2();
  const std::vector<Request> requests = createRequests(expand_dims::get_examples_int32_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, expand_dims_3) {
  generated_tests::Execute(device,
                           expand_dims::createTestModel_3,
                           expand_dims::is_ignored_3,
                           expand_dims::get_examples_3());
}

TEST_F(ValidationTest, expand_dims_3) {
  const Model model = expand_dims::createTestModel_3();
  const std::vector<Request> requests = createRequests(expand_dims::get_examples_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, expand_dims_relaxed_3) {
  generated_tests::Execute(device,
                           expand_dims::createTestModel_relaxed_3,
                           expand_dims::is_ignored_relaxed_3,
                           expand_dims::get_examples_relaxed_3());
}

TEST_F(ValidationTest, expand_dims_relaxed_3) {
  const Model model = expand_dims::createTestModel_relaxed_3();
  const std::vector<Request> requests = createRequests(expand_dims::get_examples_relaxed_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, expand_dims_quant8_3) {
  generated_tests::Execute(device,
                           expand_dims::createTestModel_quant8_3,
                           expand_dims::is_ignored_quant8_3,
                           expand_dims::get_examples_quant8_3());
}

TEST_F(ValidationTest, expand_dims_quant8_3) {
  const Model model = expand_dims::createTestModel_quant8_3();
  const std::vector<Request> requests = createRequests(expand_dims::get_examples_quant8_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, expand_dims_int32_3) {
  generated_tests::Execute(device,
                           expand_dims::createTestModel_int32_3,
                           expand_dims::is_ignored_int32_3,
                           expand_dims::get_examples_int32_3());
}

TEST_F(ValidationTest, expand_dims_int32_3) {
  const Model model = expand_dims::createTestModel_int32_3();
  const std::vector<Request> requests = createRequests(expand_dims::get_examples_int32_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, expand_dims_4) {
  generated_tests::Execute(device,
                           expand_dims::createTestModel_4,
                           expand_dims::is_ignored_4,
                           expand_dims::get_examples_4());
}

TEST_F(ValidationTest, expand_dims_4) {
  const Model model = expand_dims::createTestModel_4();
  const std::vector<Request> requests = createRequests(expand_dims::get_examples_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, expand_dims_relaxed_4) {
  generated_tests::Execute(device,
                           expand_dims::createTestModel_relaxed_4,
                           expand_dims::is_ignored_relaxed_4,
                           expand_dims::get_examples_relaxed_4());
}

TEST_F(ValidationTest, expand_dims_relaxed_4) {
  const Model model = expand_dims::createTestModel_relaxed_4();
  const std::vector<Request> requests = createRequests(expand_dims::get_examples_relaxed_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, expand_dims_quant8_4) {
  generated_tests::Execute(device,
                           expand_dims::createTestModel_quant8_4,
                           expand_dims::is_ignored_quant8_4,
                           expand_dims::get_examples_quant8_4());
}

TEST_F(ValidationTest, expand_dims_quant8_4) {
  const Model model = expand_dims::createTestModel_quant8_4();
  const std::vector<Request> requests = createRequests(expand_dims::get_examples_quant8_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, expand_dims_int32_4) {
  generated_tests::Execute(device,
                           expand_dims::createTestModel_int32_4,
                           expand_dims::is_ignored_int32_4,
                           expand_dims::get_examples_int32_4());
}

TEST_F(ValidationTest, expand_dims_int32_4) {
  const Model model = expand_dims::createTestModel_int32_4();
  const std::vector<Request> requests = createRequests(expand_dims::get_examples_int32_4());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: gather.mod.py.
namespace gather {
// Generated gather test
#include "examples/gather.example.cpp"
// Generated model constructor
#include "vts_models/gather.model.cpp"
} // namespace gather

TEST_F(NeuralnetworksHidlTest, gather) {
  generated_tests::Execute(device,
                           gather::createTestModel,
                           gather::is_ignored,
                           gather::get_examples());
}

TEST_F(ValidationTest, gather) {
  const Model model = gather::createTestModel();
  const std::vector<Request> requests = createRequests(gather::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_relaxed) {
  generated_tests::Execute(device,
                           gather::createTestModel_relaxed,
                           gather::is_ignored_relaxed,
                           gather::get_examples_relaxed());
}

TEST_F(ValidationTest, gather_relaxed) {
  const Model model = gather::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(gather::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_quant8) {
  generated_tests::Execute(device,
                           gather::createTestModel_quant8,
                           gather::is_ignored_quant8,
                           gather::get_examples_quant8());
}

TEST_F(ValidationTest, gather_quant8) {
  const Model model = gather::createTestModel_quant8();
  const std::vector<Request> requests = createRequests(gather::get_examples_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_int32) {
  generated_tests::Execute(device,
                           gather::createTestModel_int32,
                           gather::is_ignored_int32,
                           gather::get_examples_int32());
}

TEST_F(ValidationTest, gather_int32) {
  const Model model = gather::createTestModel_int32();
  const std::vector<Request> requests = createRequests(gather::get_examples_int32());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_float16) {
  generated_tests::Execute(device,
                           gather::createTestModel_float16,
                           gather::is_ignored_float16,
                           gather::get_examples_float16());
}

TEST_F(ValidationTest, gather_float16) {
  const Model model = gather::createTestModel_float16();
  const std::vector<Request> requests = createRequests(gather::get_examples_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_2) {
  generated_tests::Execute(device,
                           gather::createTestModel_2,
                           gather::is_ignored_2,
                           gather::get_examples_2());
}

TEST_F(ValidationTest, gather_2) {
  const Model model = gather::createTestModel_2();
  const std::vector<Request> requests = createRequests(gather::get_examples_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_relaxed_2) {
  generated_tests::Execute(device,
                           gather::createTestModel_relaxed_2,
                           gather::is_ignored_relaxed_2,
                           gather::get_examples_relaxed_2());
}

TEST_F(ValidationTest, gather_relaxed_2) {
  const Model model = gather::createTestModel_relaxed_2();
  const std::vector<Request> requests = createRequests(gather::get_examples_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_quant8_2) {
  generated_tests::Execute(device,
                           gather::createTestModel_quant8_2,
                           gather::is_ignored_quant8_2,
                           gather::get_examples_quant8_2());
}

TEST_F(ValidationTest, gather_quant8_2) {
  const Model model = gather::createTestModel_quant8_2();
  const std::vector<Request> requests = createRequests(gather::get_examples_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_int32_2) {
  generated_tests::Execute(device,
                           gather::createTestModel_int32_2,
                           gather::is_ignored_int32_2,
                           gather::get_examples_int32_2());
}

TEST_F(ValidationTest, gather_int32_2) {
  const Model model = gather::createTestModel_int32_2();
  const std::vector<Request> requests = createRequests(gather::get_examples_int32_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_float16_2) {
  generated_tests::Execute(device,
                           gather::createTestModel_float16_2,
                           gather::is_ignored_float16_2,
                           gather::get_examples_float16_2());
}

TEST_F(ValidationTest, gather_float16_2) {
  const Model model = gather::createTestModel_float16_2();
  const std::vector<Request> requests = createRequests(gather::get_examples_float16_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_3) {
  generated_tests::Execute(device,
                           gather::createTestModel_3,
                           gather::is_ignored_3,
                           gather::get_examples_3());
}

TEST_F(ValidationTest, gather_3) {
  const Model model = gather::createTestModel_3();
  const std::vector<Request> requests = createRequests(gather::get_examples_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_relaxed_3) {
  generated_tests::Execute(device,
                           gather::createTestModel_relaxed_3,
                           gather::is_ignored_relaxed_3,
                           gather::get_examples_relaxed_3());
}

TEST_F(ValidationTest, gather_relaxed_3) {
  const Model model = gather::createTestModel_relaxed_3();
  const std::vector<Request> requests = createRequests(gather::get_examples_relaxed_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_quant8_3) {
  generated_tests::Execute(device,
                           gather::createTestModel_quant8_3,
                           gather::is_ignored_quant8_3,
                           gather::get_examples_quant8_3());
}

TEST_F(ValidationTest, gather_quant8_3) {
  const Model model = gather::createTestModel_quant8_3();
  const std::vector<Request> requests = createRequests(gather::get_examples_quant8_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_int32_3) {
  generated_tests::Execute(device,
                           gather::createTestModel_int32_3,
                           gather::is_ignored_int32_3,
                           gather::get_examples_int32_3());
}

TEST_F(ValidationTest, gather_int32_3) {
  const Model model = gather::createTestModel_int32_3();
  const std::vector<Request> requests = createRequests(gather::get_examples_int32_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_float16_3) {
  generated_tests::Execute(device,
                           gather::createTestModel_float16_3,
                           gather::is_ignored_float16_3,
                           gather::get_examples_float16_3());
}

TEST_F(ValidationTest, gather_float16_3) {
  const Model model = gather::createTestModel_float16_3();
  const std::vector<Request> requests = createRequests(gather::get_examples_float16_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_4) {
  generated_tests::Execute(device,
                           gather::createTestModel_4,
                           gather::is_ignored_4,
                           gather::get_examples_4());
}

TEST_F(ValidationTest, gather_4) {
  const Model model = gather::createTestModel_4();
  const std::vector<Request> requests = createRequests(gather::get_examples_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_relaxed_4) {
  generated_tests::Execute(device,
                           gather::createTestModel_relaxed_4,
                           gather::is_ignored_relaxed_4,
                           gather::get_examples_relaxed_4());
}

TEST_F(ValidationTest, gather_relaxed_4) {
  const Model model = gather::createTestModel_relaxed_4();
  const std::vector<Request> requests = createRequests(gather::get_examples_relaxed_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_quant8_4) {
  generated_tests::Execute(device,
                           gather::createTestModel_quant8_4,
                           gather::is_ignored_quant8_4,
                           gather::get_examples_quant8_4());
}

TEST_F(ValidationTest, gather_quant8_4) {
  const Model model = gather::createTestModel_quant8_4();
  const std::vector<Request> requests = createRequests(gather::get_examples_quant8_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_int32_4) {
  generated_tests::Execute(device,
                           gather::createTestModel_int32_4,
                           gather::is_ignored_int32_4,
                           gather::get_examples_int32_4());
}

TEST_F(ValidationTest, gather_int32_4) {
  const Model model = gather::createTestModel_int32_4();
  const std::vector<Request> requests = createRequests(gather::get_examples_int32_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_float16_4) {
  generated_tests::Execute(device,
                           gather::createTestModel_float16_4,
                           gather::is_ignored_float16_4,
                           gather::get_examples_float16_4());
}

TEST_F(ValidationTest, gather_float16_4) {
  const Model model = gather::createTestModel_float16_4();
  const std::vector<Request> requests = createRequests(gather::get_examples_float16_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_5) {
  generated_tests::Execute(device,
                           gather::createTestModel_5,
                           gather::is_ignored_5,
                           gather::get_examples_5());
}

TEST_F(ValidationTest, gather_5) {
  const Model model = gather::createTestModel_5();
  const std::vector<Request> requests = createRequests(gather::get_examples_5());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_relaxed_5) {
  generated_tests::Execute(device,
                           gather::createTestModel_relaxed_5,
                           gather::is_ignored_relaxed_5,
                           gather::get_examples_relaxed_5());
}

TEST_F(ValidationTest, gather_relaxed_5) {
  const Model model = gather::createTestModel_relaxed_5();
  const std::vector<Request> requests = createRequests(gather::get_examples_relaxed_5());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_quant8_5) {
  generated_tests::Execute(device,
                           gather::createTestModel_quant8_5,
                           gather::is_ignored_quant8_5,
                           gather::get_examples_quant8_5());
}

TEST_F(ValidationTest, gather_quant8_5) {
  const Model model = gather::createTestModel_quant8_5();
  const std::vector<Request> requests = createRequests(gather::get_examples_quant8_5());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_int32_5) {
  generated_tests::Execute(device,
                           gather::createTestModel_int32_5,
                           gather::is_ignored_int32_5,
                           gather::get_examples_int32_5());
}

TEST_F(ValidationTest, gather_int32_5) {
  const Model model = gather::createTestModel_int32_5();
  const std::vector<Request> requests = createRequests(gather::get_examples_int32_5());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_float16_5) {
  generated_tests::Execute(device,
                           gather::createTestModel_float16_5,
                           gather::is_ignored_float16_5,
                           gather::get_examples_float16_5());
}

TEST_F(ValidationTest, gather_float16_5) {
  const Model model = gather::createTestModel_float16_5();
  const std::vector<Request> requests = createRequests(gather::get_examples_float16_5());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_6) {
  generated_tests::Execute(device,
                           gather::createTestModel_6,
                           gather::is_ignored_6,
                           gather::get_examples_6());
}

TEST_F(ValidationTest, gather_6) {
  const Model model = gather::createTestModel_6();
  const std::vector<Request> requests = createRequests(gather::get_examples_6());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_relaxed_6) {
  generated_tests::Execute(device,
                           gather::createTestModel_relaxed_6,
                           gather::is_ignored_relaxed_6,
                           gather::get_examples_relaxed_6());
}

TEST_F(ValidationTest, gather_relaxed_6) {
  const Model model = gather::createTestModel_relaxed_6();
  const std::vector<Request> requests = createRequests(gather::get_examples_relaxed_6());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_quant8_6) {
  generated_tests::Execute(device,
                           gather::createTestModel_quant8_6,
                           gather::is_ignored_quant8_6,
                           gather::get_examples_quant8_6());
}

TEST_F(ValidationTest, gather_quant8_6) {
  const Model model = gather::createTestModel_quant8_6();
  const std::vector<Request> requests = createRequests(gather::get_examples_quant8_6());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_int32_6) {
  generated_tests::Execute(device,
                           gather::createTestModel_int32_6,
                           gather::is_ignored_int32_6,
                           gather::get_examples_int32_6());
}

TEST_F(ValidationTest, gather_int32_6) {
  const Model model = gather::createTestModel_int32_6();
  const std::vector<Request> requests = createRequests(gather::get_examples_int32_6());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_float16_6) {
  generated_tests::Execute(device,
                           gather::createTestModel_float16_6,
                           gather::is_ignored_float16_6,
                           gather::get_examples_float16_6());
}

TEST_F(ValidationTest, gather_float16_6) {
  const Model model = gather::createTestModel_float16_6();
  const std::vector<Request> requests = createRequests(gather::get_examples_float16_6());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_7) {
  generated_tests::Execute(device,
                           gather::createTestModel_7,
                           gather::is_ignored_7,
                           gather::get_examples_7());
}

TEST_F(ValidationTest, gather_7) {
  const Model model = gather::createTestModel_7();
  const std::vector<Request> requests = createRequests(gather::get_examples_7());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_relaxed_7) {
  generated_tests::Execute(device,
                           gather::createTestModel_relaxed_7,
                           gather::is_ignored_relaxed_7,
                           gather::get_examples_relaxed_7());
}

TEST_F(ValidationTest, gather_relaxed_7) {
  const Model model = gather::createTestModel_relaxed_7();
  const std::vector<Request> requests = createRequests(gather::get_examples_relaxed_7());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_quant8_7) {
  generated_tests::Execute(device,
                           gather::createTestModel_quant8_7,
                           gather::is_ignored_quant8_7,
                           gather::get_examples_quant8_7());
}

TEST_F(ValidationTest, gather_quant8_7) {
  const Model model = gather::createTestModel_quant8_7();
  const std::vector<Request> requests = createRequests(gather::get_examples_quant8_7());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_int32_7) {
  generated_tests::Execute(device,
                           gather::createTestModel_int32_7,
                           gather::is_ignored_int32_7,
                           gather::get_examples_int32_7());
}

TEST_F(ValidationTest, gather_int32_7) {
  const Model model = gather::createTestModel_int32_7();
  const std::vector<Request> requests = createRequests(gather::get_examples_int32_7());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_float16_7) {
  generated_tests::Execute(device,
                           gather::createTestModel_float16_7,
                           gather::is_ignored_float16_7,
                           gather::get_examples_float16_7());
}

TEST_F(ValidationTest, gather_float16_7) {
  const Model model = gather::createTestModel_float16_7();
  const std::vector<Request> requests = createRequests(gather::get_examples_float16_7());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_8) {
  generated_tests::Execute(device,
                           gather::createTestModel_8,
                           gather::is_ignored_8,
                           gather::get_examples_8());
}

TEST_F(ValidationTest, gather_8) {
  const Model model = gather::createTestModel_8();
  const std::vector<Request> requests = createRequests(gather::get_examples_8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_relaxed_8) {
  generated_tests::Execute(device,
                           gather::createTestModel_relaxed_8,
                           gather::is_ignored_relaxed_8,
                           gather::get_examples_relaxed_8());
}

TEST_F(ValidationTest, gather_relaxed_8) {
  const Model model = gather::createTestModel_relaxed_8();
  const std::vector<Request> requests = createRequests(gather::get_examples_relaxed_8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_quant8_8) {
  generated_tests::Execute(device,
                           gather::createTestModel_quant8_8,
                           gather::is_ignored_quant8_8,
                           gather::get_examples_quant8_8());
}

TEST_F(ValidationTest, gather_quant8_8) {
  const Model model = gather::createTestModel_quant8_8();
  const std::vector<Request> requests = createRequests(gather::get_examples_quant8_8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_int32_8) {
  generated_tests::Execute(device,
                           gather::createTestModel_int32_8,
                           gather::is_ignored_int32_8,
                           gather::get_examples_int32_8());
}

TEST_F(ValidationTest, gather_int32_8) {
  const Model model = gather::createTestModel_int32_8();
  const std::vector<Request> requests = createRequests(gather::get_examples_int32_8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_float16_8) {
  generated_tests::Execute(device,
                           gather::createTestModel_float16_8,
                           gather::is_ignored_float16_8,
                           gather::get_examples_float16_8());
}

TEST_F(ValidationTest, gather_float16_8) {
  const Model model = gather::createTestModel_float16_8();
  const std::vector<Request> requests = createRequests(gather::get_examples_float16_8());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: gather_higher_rank.mod.py.
namespace gather_higher_rank {
// Generated gather_higher_rank test
#include "examples/gather_higher_rank.example.cpp"
// Generated model constructor
#include "vts_models/gather_higher_rank.model.cpp"
} // namespace gather_higher_rank

TEST_F(NeuralnetworksHidlTest, gather_higher_rank) {
  generated_tests::Execute(device,
                           gather_higher_rank::createTestModel,
                           gather_higher_rank::is_ignored,
                           gather_higher_rank::get_examples());
}

TEST_F(ValidationTest, gather_higher_rank) {
  const Model model = gather_higher_rank::createTestModel();
  const std::vector<Request> requests = createRequests(gather_higher_rank::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_higher_rank_relaxed) {
  generated_tests::Execute(device,
                           gather_higher_rank::createTestModel_relaxed,
                           gather_higher_rank::is_ignored_relaxed,
                           gather_higher_rank::get_examples_relaxed());
}

TEST_F(ValidationTest, gather_higher_rank_relaxed) {
  const Model model = gather_higher_rank::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(gather_higher_rank::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_higher_rank_quant8) {
  generated_tests::Execute(device,
                           gather_higher_rank::createTestModel_quant8,
                           gather_higher_rank::is_ignored_quant8,
                           gather_higher_rank::get_examples_quant8());
}

TEST_F(ValidationTest, gather_higher_rank_quant8) {
  const Model model = gather_higher_rank::createTestModel_quant8();
  const std::vector<Request> requests = createRequests(gather_higher_rank::get_examples_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, gather_higher_rank_int32) {
  generated_tests::Execute(device,
                           gather_higher_rank::createTestModel_int32,
                           gather_higher_rank::is_ignored_int32,
                           gather_higher_rank::get_examples_int32());
}

TEST_F(ValidationTest, gather_higher_rank_int32) {
  const Model model = gather_higher_rank::createTestModel_int32();
  const std::vector<Request> requests = createRequests(gather_higher_rank::get_examples_int32());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: grouped_conv2d.mod.py.
namespace grouped_conv2d {
// Generated grouped_conv2d test
#include "examples/grouped_conv2d.example.cpp"
// Generated model constructor
#include "vts_models/grouped_conv2d.model.cpp"
} // namespace grouped_conv2d

TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_none) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_none,
                           grouped_conv2d::is_ignored_nhwc_none,
                           grouped_conv2d::get_examples_nhwc_none());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_none) {
  const Model model = grouped_conv2d::createTestModel_nhwc_none();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_none());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_none_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_none_weight_as_input,
                           grouped_conv2d::is_ignored_nhwc_none_weight_as_input,
                           grouped_conv2d::get_examples_nhwc_none_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_none_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nhwc_none_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_none_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_none_relaxed) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_none_relaxed,
                           grouped_conv2d::is_ignored_nhwc_none_relaxed,
                           grouped_conv2d::get_examples_nhwc_none_relaxed());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_none_relaxed) {
  const Model model = grouped_conv2d::createTestModel_nhwc_none_relaxed();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_none_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_none_relaxed_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_none_relaxed_weight_as_input,
                           grouped_conv2d::is_ignored_nhwc_none_relaxed_weight_as_input,
                           grouped_conv2d::get_examples_nhwc_none_relaxed_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_none_relaxed_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nhwc_none_relaxed_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_none_relaxed_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_none_quant8) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_none_quant8,
                           grouped_conv2d::is_ignored_nhwc_none_quant8,
                           grouped_conv2d::get_examples_nhwc_none_quant8());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_none_quant8) {
  const Model model = grouped_conv2d::createTestModel_nhwc_none_quant8();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_none_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_none_quant8_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_none_quant8_weight_as_input,
                           grouped_conv2d::is_ignored_nhwc_none_quant8_weight_as_input,
                           grouped_conv2d::get_examples_nhwc_none_quant8_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_none_quant8_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nhwc_none_quant8_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_none_quant8_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_relu) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_relu,
                           grouped_conv2d::is_ignored_nhwc_relu,
                           grouped_conv2d::get_examples_nhwc_relu());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_relu) {
  const Model model = grouped_conv2d::createTestModel_nhwc_relu();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_relu());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_relu_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_relu_weight_as_input,
                           grouped_conv2d::is_ignored_nhwc_relu_weight_as_input,
                           grouped_conv2d::get_examples_nhwc_relu_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_relu_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nhwc_relu_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_relu_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_relu_relaxed) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_relu_relaxed,
                           grouped_conv2d::is_ignored_nhwc_relu_relaxed,
                           grouped_conv2d::get_examples_nhwc_relu_relaxed());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_relu_relaxed) {
  const Model model = grouped_conv2d::createTestModel_nhwc_relu_relaxed();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_relu_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_relu_relaxed_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_relu_relaxed_weight_as_input,
                           grouped_conv2d::is_ignored_nhwc_relu_relaxed_weight_as_input,
                           grouped_conv2d::get_examples_nhwc_relu_relaxed_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_relu_relaxed_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nhwc_relu_relaxed_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_relu_relaxed_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_relu_quant8) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_relu_quant8,
                           grouped_conv2d::is_ignored_nhwc_relu_quant8,
                           grouped_conv2d::get_examples_nhwc_relu_quant8());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_relu_quant8) {
  const Model model = grouped_conv2d::createTestModel_nhwc_relu_quant8();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_relu_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_relu_quant8_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_relu_quant8_weight_as_input,
                           grouped_conv2d::is_ignored_nhwc_relu_quant8_weight_as_input,
                           grouped_conv2d::get_examples_nhwc_relu_quant8_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_relu_quant8_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nhwc_relu_quant8_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_relu_quant8_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_relu1) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_relu1,
                           grouped_conv2d::is_ignored_nhwc_relu1,
                           grouped_conv2d::get_examples_nhwc_relu1());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_relu1) {
  const Model model = grouped_conv2d::createTestModel_nhwc_relu1();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_relu1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_relu1_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_relu1_weight_as_input,
                           grouped_conv2d::is_ignored_nhwc_relu1_weight_as_input,
                           grouped_conv2d::get_examples_nhwc_relu1_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_relu1_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nhwc_relu1_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_relu1_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_relu1_relaxed) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_relu1_relaxed,
                           grouped_conv2d::is_ignored_nhwc_relu1_relaxed,
                           grouped_conv2d::get_examples_nhwc_relu1_relaxed());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_relu1_relaxed) {
  const Model model = grouped_conv2d::createTestModel_nhwc_relu1_relaxed();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_relu1_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_relu1_relaxed_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_relu1_relaxed_weight_as_input,
                           grouped_conv2d::is_ignored_nhwc_relu1_relaxed_weight_as_input,
                           grouped_conv2d::get_examples_nhwc_relu1_relaxed_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_relu1_relaxed_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nhwc_relu1_relaxed_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_relu1_relaxed_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_relu1_quant8) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_relu1_quant8,
                           grouped_conv2d::is_ignored_nhwc_relu1_quant8,
                           grouped_conv2d::get_examples_nhwc_relu1_quant8());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_relu1_quant8) {
  const Model model = grouped_conv2d::createTestModel_nhwc_relu1_quant8();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_relu1_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_relu1_quant8_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_relu1_quant8_weight_as_input,
                           grouped_conv2d::is_ignored_nhwc_relu1_quant8_weight_as_input,
                           grouped_conv2d::get_examples_nhwc_relu1_quant8_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_relu1_quant8_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nhwc_relu1_quant8_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_relu1_quant8_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_relu6) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_relu6,
                           grouped_conv2d::is_ignored_nhwc_relu6,
                           grouped_conv2d::get_examples_nhwc_relu6());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_relu6) {
  const Model model = grouped_conv2d::createTestModel_nhwc_relu6();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_relu6());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_relu6_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_relu6_weight_as_input,
                           grouped_conv2d::is_ignored_nhwc_relu6_weight_as_input,
                           grouped_conv2d::get_examples_nhwc_relu6_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_relu6_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nhwc_relu6_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_relu6_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_relu6_relaxed) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_relu6_relaxed,
                           grouped_conv2d::is_ignored_nhwc_relu6_relaxed,
                           grouped_conv2d::get_examples_nhwc_relu6_relaxed());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_relu6_relaxed) {
  const Model model = grouped_conv2d::createTestModel_nhwc_relu6_relaxed();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_relu6_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_relu6_relaxed_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_relu6_relaxed_weight_as_input,
                           grouped_conv2d::is_ignored_nhwc_relu6_relaxed_weight_as_input,
                           grouped_conv2d::get_examples_nhwc_relu6_relaxed_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_relu6_relaxed_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nhwc_relu6_relaxed_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_relu6_relaxed_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_relu6_quant8) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_relu6_quant8,
                           grouped_conv2d::is_ignored_nhwc_relu6_quant8,
                           grouped_conv2d::get_examples_nhwc_relu6_quant8());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_relu6_quant8) {
  const Model model = grouped_conv2d::createTestModel_nhwc_relu6_quant8();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_relu6_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nhwc_relu6_quant8_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nhwc_relu6_quant8_weight_as_input,
                           grouped_conv2d::is_ignored_nhwc_relu6_quant8_weight_as_input,
                           grouped_conv2d::get_examples_nhwc_relu6_quant8_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nhwc_relu6_quant8_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nhwc_relu6_quant8_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nhwc_relu6_quant8_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_none) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_none,
                           grouped_conv2d::is_ignored_nchw_none,
                           grouped_conv2d::get_examples_nchw_none());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_none) {
  const Model model = grouped_conv2d::createTestModel_nchw_none();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_none());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_none_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_none_weight_as_input,
                           grouped_conv2d::is_ignored_nchw_none_weight_as_input,
                           grouped_conv2d::get_examples_nchw_none_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_none_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nchw_none_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_none_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_none_relaxed) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_none_relaxed,
                           grouped_conv2d::is_ignored_nchw_none_relaxed,
                           grouped_conv2d::get_examples_nchw_none_relaxed());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_none_relaxed) {
  const Model model = grouped_conv2d::createTestModel_nchw_none_relaxed();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_none_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_none_relaxed_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_none_relaxed_weight_as_input,
                           grouped_conv2d::is_ignored_nchw_none_relaxed_weight_as_input,
                           grouped_conv2d::get_examples_nchw_none_relaxed_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_none_relaxed_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nchw_none_relaxed_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_none_relaxed_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_none_quant8) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_none_quant8,
                           grouped_conv2d::is_ignored_nchw_none_quant8,
                           grouped_conv2d::get_examples_nchw_none_quant8());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_none_quant8) {
  const Model model = grouped_conv2d::createTestModel_nchw_none_quant8();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_none_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_none_quant8_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_none_quant8_weight_as_input,
                           grouped_conv2d::is_ignored_nchw_none_quant8_weight_as_input,
                           grouped_conv2d::get_examples_nchw_none_quant8_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_none_quant8_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nchw_none_quant8_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_none_quant8_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_relu) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_relu,
                           grouped_conv2d::is_ignored_nchw_relu,
                           grouped_conv2d::get_examples_nchw_relu());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_relu) {
  const Model model = grouped_conv2d::createTestModel_nchw_relu();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_relu());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_relu_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_relu_weight_as_input,
                           grouped_conv2d::is_ignored_nchw_relu_weight_as_input,
                           grouped_conv2d::get_examples_nchw_relu_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_relu_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nchw_relu_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_relu_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_relu_relaxed) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_relu_relaxed,
                           grouped_conv2d::is_ignored_nchw_relu_relaxed,
                           grouped_conv2d::get_examples_nchw_relu_relaxed());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_relu_relaxed) {
  const Model model = grouped_conv2d::createTestModel_nchw_relu_relaxed();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_relu_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_relu_relaxed_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_relu_relaxed_weight_as_input,
                           grouped_conv2d::is_ignored_nchw_relu_relaxed_weight_as_input,
                           grouped_conv2d::get_examples_nchw_relu_relaxed_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_relu_relaxed_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nchw_relu_relaxed_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_relu_relaxed_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_relu_quant8) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_relu_quant8,
                           grouped_conv2d::is_ignored_nchw_relu_quant8,
                           grouped_conv2d::get_examples_nchw_relu_quant8());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_relu_quant8) {
  const Model model = grouped_conv2d::createTestModel_nchw_relu_quant8();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_relu_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_relu_quant8_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_relu_quant8_weight_as_input,
                           grouped_conv2d::is_ignored_nchw_relu_quant8_weight_as_input,
                           grouped_conv2d::get_examples_nchw_relu_quant8_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_relu_quant8_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nchw_relu_quant8_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_relu_quant8_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_relu1) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_relu1,
                           grouped_conv2d::is_ignored_nchw_relu1,
                           grouped_conv2d::get_examples_nchw_relu1());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_relu1) {
  const Model model = grouped_conv2d::createTestModel_nchw_relu1();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_relu1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_relu1_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_relu1_weight_as_input,
                           grouped_conv2d::is_ignored_nchw_relu1_weight_as_input,
                           grouped_conv2d::get_examples_nchw_relu1_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_relu1_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nchw_relu1_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_relu1_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_relu1_relaxed) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_relu1_relaxed,
                           grouped_conv2d::is_ignored_nchw_relu1_relaxed,
                           grouped_conv2d::get_examples_nchw_relu1_relaxed());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_relu1_relaxed) {
  const Model model = grouped_conv2d::createTestModel_nchw_relu1_relaxed();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_relu1_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_relu1_relaxed_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_relu1_relaxed_weight_as_input,
                           grouped_conv2d::is_ignored_nchw_relu1_relaxed_weight_as_input,
                           grouped_conv2d::get_examples_nchw_relu1_relaxed_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_relu1_relaxed_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nchw_relu1_relaxed_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_relu1_relaxed_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_relu1_quant8) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_relu1_quant8,
                           grouped_conv2d::is_ignored_nchw_relu1_quant8,
                           grouped_conv2d::get_examples_nchw_relu1_quant8());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_relu1_quant8) {
  const Model model = grouped_conv2d::createTestModel_nchw_relu1_quant8();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_relu1_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_relu1_quant8_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_relu1_quant8_weight_as_input,
                           grouped_conv2d::is_ignored_nchw_relu1_quant8_weight_as_input,
                           grouped_conv2d::get_examples_nchw_relu1_quant8_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_relu1_quant8_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nchw_relu1_quant8_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_relu1_quant8_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_relu6) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_relu6,
                           grouped_conv2d::is_ignored_nchw_relu6,
                           grouped_conv2d::get_examples_nchw_relu6());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_relu6) {
  const Model model = grouped_conv2d::createTestModel_nchw_relu6();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_relu6());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_relu6_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_relu6_weight_as_input,
                           grouped_conv2d::is_ignored_nchw_relu6_weight_as_input,
                           grouped_conv2d::get_examples_nchw_relu6_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_relu6_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nchw_relu6_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_relu6_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_relu6_relaxed) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_relu6_relaxed,
                           grouped_conv2d::is_ignored_nchw_relu6_relaxed,
                           grouped_conv2d::get_examples_nchw_relu6_relaxed());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_relu6_relaxed) {
  const Model model = grouped_conv2d::createTestModel_nchw_relu6_relaxed();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_relu6_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_relu6_relaxed_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_relu6_relaxed_weight_as_input,
                           grouped_conv2d::is_ignored_nchw_relu6_relaxed_weight_as_input,
                           grouped_conv2d::get_examples_nchw_relu6_relaxed_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_relu6_relaxed_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nchw_relu6_relaxed_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_relu6_relaxed_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_relu6_quant8) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_relu6_quant8,
                           grouped_conv2d::is_ignored_nchw_relu6_quant8,
                           grouped_conv2d::get_examples_nchw_relu6_quant8());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_relu6_quant8) {
  const Model model = grouped_conv2d::createTestModel_nchw_relu6_quant8();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_relu6_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_nchw_relu6_quant8_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_nchw_relu6_quant8_weight_as_input,
                           grouped_conv2d::is_ignored_nchw_relu6_quant8_weight_as_input,
                           grouped_conv2d::get_examples_nchw_relu6_quant8_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_nchw_relu6_quant8_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_nchw_relu6_quant8_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_nchw_relu6_quant8_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_large_nhwc) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_large_nhwc,
                           grouped_conv2d::is_ignored_large_nhwc,
                           grouped_conv2d::get_examples_large_nhwc());
}

TEST_F(ValidationTest, grouped_conv2d_large_nhwc) {
  const Model model = grouped_conv2d::createTestModel_large_nhwc();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_large_nhwc());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_large_nhwc_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_large_nhwc_weight_as_input,
                           grouped_conv2d::is_ignored_large_nhwc_weight_as_input,
                           grouped_conv2d::get_examples_large_nhwc_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_large_nhwc_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_large_nhwc_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_large_nhwc_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_large_nhwc_relaxed) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_large_nhwc_relaxed,
                           grouped_conv2d::is_ignored_large_nhwc_relaxed,
                           grouped_conv2d::get_examples_large_nhwc_relaxed());
}

TEST_F(ValidationTest, grouped_conv2d_large_nhwc_relaxed) {
  const Model model = grouped_conv2d::createTestModel_large_nhwc_relaxed();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_large_nhwc_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_large_nhwc_relaxed_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_large_nhwc_relaxed_weight_as_input,
                           grouped_conv2d::is_ignored_large_nhwc_relaxed_weight_as_input,
                           grouped_conv2d::get_examples_large_nhwc_relaxed_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_large_nhwc_relaxed_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_large_nhwc_relaxed_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_large_nhwc_relaxed_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_large_nhwc_quant8) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_large_nhwc_quant8,
                           grouped_conv2d::is_ignored_large_nhwc_quant8,
                           grouped_conv2d::get_examples_large_nhwc_quant8());
}

TEST_F(ValidationTest, grouped_conv2d_large_nhwc_quant8) {
  const Model model = grouped_conv2d::createTestModel_large_nhwc_quant8();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_large_nhwc_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_large_nhwc_quant8_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_large_nhwc_quant8_weight_as_input,
                           grouped_conv2d::is_ignored_large_nhwc_quant8_weight_as_input,
                           grouped_conv2d::get_examples_large_nhwc_quant8_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_large_nhwc_quant8_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_large_nhwc_quant8_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_large_nhwc_quant8_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_large_nchw) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_large_nchw,
                           grouped_conv2d::is_ignored_large_nchw,
                           grouped_conv2d::get_examples_large_nchw());
}

TEST_F(ValidationTest, grouped_conv2d_large_nchw) {
  const Model model = grouped_conv2d::createTestModel_large_nchw();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_large_nchw());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_large_nchw_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_large_nchw_weight_as_input,
                           grouped_conv2d::is_ignored_large_nchw_weight_as_input,
                           grouped_conv2d::get_examples_large_nchw_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_large_nchw_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_large_nchw_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_large_nchw_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_large_nchw_relaxed) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_large_nchw_relaxed,
                           grouped_conv2d::is_ignored_large_nchw_relaxed,
                           grouped_conv2d::get_examples_large_nchw_relaxed());
}

TEST_F(ValidationTest, grouped_conv2d_large_nchw_relaxed) {
  const Model model = grouped_conv2d::createTestModel_large_nchw_relaxed();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_large_nchw_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_large_nchw_relaxed_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_large_nchw_relaxed_weight_as_input,
                           grouped_conv2d::is_ignored_large_nchw_relaxed_weight_as_input,
                           grouped_conv2d::get_examples_large_nchw_relaxed_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_large_nchw_relaxed_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_large_nchw_relaxed_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_large_nchw_relaxed_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_large_nchw_quant8) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_large_nchw_quant8,
                           grouped_conv2d::is_ignored_large_nchw_quant8,
                           grouped_conv2d::get_examples_large_nchw_quant8());
}

TEST_F(ValidationTest, grouped_conv2d_large_nchw_quant8) {
  const Model model = grouped_conv2d::createTestModel_large_nchw_quant8();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_large_nchw_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_large_nchw_quant8_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_large_nchw_quant8_weight_as_input,
                           grouped_conv2d::is_ignored_large_nchw_quant8_weight_as_input,
                           grouped_conv2d::get_examples_large_nchw_quant8_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_large_nchw_quant8_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_large_nchw_quant8_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_large_nchw_quant8_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_channel_nhwc) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_channel_nhwc,
                           grouped_conv2d::is_ignored_channel_nhwc,
                           grouped_conv2d::get_examples_channel_nhwc());
}

TEST_F(ValidationTest, grouped_conv2d_channel_nhwc) {
  const Model model = grouped_conv2d::createTestModel_channel_nhwc();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_channel_nhwc());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_channel_nhwc_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_channel_nhwc_weight_as_input,
                           grouped_conv2d::is_ignored_channel_nhwc_weight_as_input,
                           grouped_conv2d::get_examples_channel_nhwc_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_channel_nhwc_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_channel_nhwc_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_channel_nhwc_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_channel_nhwc_relaxed) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_channel_nhwc_relaxed,
                           grouped_conv2d::is_ignored_channel_nhwc_relaxed,
                           grouped_conv2d::get_examples_channel_nhwc_relaxed());
}

TEST_F(ValidationTest, grouped_conv2d_channel_nhwc_relaxed) {
  const Model model = grouped_conv2d::createTestModel_channel_nhwc_relaxed();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_channel_nhwc_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_channel_nhwc_relaxed_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_channel_nhwc_relaxed_weight_as_input,
                           grouped_conv2d::is_ignored_channel_nhwc_relaxed_weight_as_input,
                           grouped_conv2d::get_examples_channel_nhwc_relaxed_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_channel_nhwc_relaxed_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_channel_nhwc_relaxed_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_channel_nhwc_relaxed_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_channel_nhwc_quant8) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_channel_nhwc_quant8,
                           grouped_conv2d::is_ignored_channel_nhwc_quant8,
                           grouped_conv2d::get_examples_channel_nhwc_quant8());
}

TEST_F(ValidationTest, grouped_conv2d_channel_nhwc_quant8) {
  const Model model = grouped_conv2d::createTestModel_channel_nhwc_quant8();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_channel_nhwc_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_channel_nhwc_quant8_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_channel_nhwc_quant8_weight_as_input,
                           grouped_conv2d::is_ignored_channel_nhwc_quant8_weight_as_input,
                           grouped_conv2d::get_examples_channel_nhwc_quant8_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_channel_nhwc_quant8_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_channel_nhwc_quant8_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_channel_nhwc_quant8_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_channel_nchw) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_channel_nchw,
                           grouped_conv2d::is_ignored_channel_nchw,
                           grouped_conv2d::get_examples_channel_nchw());
}

TEST_F(ValidationTest, grouped_conv2d_channel_nchw) {
  const Model model = grouped_conv2d::createTestModel_channel_nchw();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_channel_nchw());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_channel_nchw_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_channel_nchw_weight_as_input,
                           grouped_conv2d::is_ignored_channel_nchw_weight_as_input,
                           grouped_conv2d::get_examples_channel_nchw_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_channel_nchw_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_channel_nchw_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_channel_nchw_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_channel_nchw_relaxed) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_channel_nchw_relaxed,
                           grouped_conv2d::is_ignored_channel_nchw_relaxed,
                           grouped_conv2d::get_examples_channel_nchw_relaxed());
}

TEST_F(ValidationTest, grouped_conv2d_channel_nchw_relaxed) {
  const Model model = grouped_conv2d::createTestModel_channel_nchw_relaxed();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_channel_nchw_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_channel_nchw_relaxed_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_channel_nchw_relaxed_weight_as_input,
                           grouped_conv2d::is_ignored_channel_nchw_relaxed_weight_as_input,
                           grouped_conv2d::get_examples_channel_nchw_relaxed_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_channel_nchw_relaxed_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_channel_nchw_relaxed_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_channel_nchw_relaxed_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_channel_nchw_quant8) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_channel_nchw_quant8,
                           grouped_conv2d::is_ignored_channel_nchw_quant8,
                           grouped_conv2d::get_examples_channel_nchw_quant8());
}

TEST_F(ValidationTest, grouped_conv2d_channel_nchw_quant8) {
  const Model model = grouped_conv2d::createTestModel_channel_nchw_quant8();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_channel_nchw_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, grouped_conv2d_channel_nchw_quant8_weight_as_input) {
  generated_tests::Execute(device,
                           grouped_conv2d::createTestModel_channel_nchw_quant8_weight_as_input,
                           grouped_conv2d::is_ignored_channel_nchw_quant8_weight_as_input,
                           grouped_conv2d::get_examples_channel_nchw_quant8_weight_as_input());
}

TEST_F(ValidationTest, grouped_conv2d_channel_nchw_quant8_weight_as_input) {
  const Model model = grouped_conv2d::createTestModel_channel_nchw_quant8_weight_as_input();
  const std::vector<Request> requests = createRequests(grouped_conv2d::get_examples_channel_nchw_quant8_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: heatmap_max_keypoint.mod.py.
namespace heatmap_max_keypoint {
// Generated heatmap_max_keypoint test
#include "examples/heatmap_max_keypoint.example.cpp"
// Generated model constructor
#include "vts_models/heatmap_max_keypoint.model.cpp"
} // namespace heatmap_max_keypoint

TEST_F(NeuralnetworksHidlTest, heatmap_max_keypoint_nhwc) {
  generated_tests::Execute(device,
                           heatmap_max_keypoint::createTestModel_nhwc,
                           heatmap_max_keypoint::is_ignored_nhwc,
                           heatmap_max_keypoint::get_examples_nhwc());
}

TEST_F(ValidationTest, heatmap_max_keypoint_nhwc) {
  const Model model = heatmap_max_keypoint::createTestModel_nhwc();
  const std::vector<Request> requests = createRequests(heatmap_max_keypoint::get_examples_nhwc());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, heatmap_max_keypoint_nhwc_relaxed) {
  generated_tests::Execute(device,
                           heatmap_max_keypoint::createTestModel_nhwc_relaxed,
                           heatmap_max_keypoint::is_ignored_nhwc_relaxed,
                           heatmap_max_keypoint::get_examples_nhwc_relaxed());
}

TEST_F(ValidationTest, heatmap_max_keypoint_nhwc_relaxed) {
  const Model model = heatmap_max_keypoint::createTestModel_nhwc_relaxed();
  const std::vector<Request> requests = createRequests(heatmap_max_keypoint::get_examples_nhwc_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, heatmap_max_keypoint_nchw) {
  generated_tests::Execute(device,
                           heatmap_max_keypoint::createTestModel_nchw,
                           heatmap_max_keypoint::is_ignored_nchw,
                           heatmap_max_keypoint::get_examples_nchw());
}

TEST_F(ValidationTest, heatmap_max_keypoint_nchw) {
  const Model model = heatmap_max_keypoint::createTestModel_nchw();
  const std::vector<Request> requests = createRequests(heatmap_max_keypoint::get_examples_nchw());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, heatmap_max_keypoint_nchw_relaxed) {
  generated_tests::Execute(device,
                           heatmap_max_keypoint::createTestModel_nchw_relaxed,
                           heatmap_max_keypoint::is_ignored_nchw_relaxed,
                           heatmap_max_keypoint::get_examples_nchw_relaxed());
}

TEST_F(ValidationTest, heatmap_max_keypoint_nchw_relaxed) {
  const Model model = heatmap_max_keypoint::createTestModel_nchw_relaxed();
  const std::vector<Request> requests = createRequests(heatmap_max_keypoint::get_examples_nchw_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, heatmap_max_keypoint_nhwc_2) {
  generated_tests::Execute(device,
                           heatmap_max_keypoint::createTestModel_nhwc_2,
                           heatmap_max_keypoint::is_ignored_nhwc_2,
                           heatmap_max_keypoint::get_examples_nhwc_2());
}

TEST_F(ValidationTest, heatmap_max_keypoint_nhwc_2) {
  const Model model = heatmap_max_keypoint::createTestModel_nhwc_2();
  const std::vector<Request> requests = createRequests(heatmap_max_keypoint::get_examples_nhwc_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, heatmap_max_keypoint_nhwc_relaxed_2) {
  generated_tests::Execute(device,
                           heatmap_max_keypoint::createTestModel_nhwc_relaxed_2,
                           heatmap_max_keypoint::is_ignored_nhwc_relaxed_2,
                           heatmap_max_keypoint::get_examples_nhwc_relaxed_2());
}

TEST_F(ValidationTest, heatmap_max_keypoint_nhwc_relaxed_2) {
  const Model model = heatmap_max_keypoint::createTestModel_nhwc_relaxed_2();
  const std::vector<Request> requests = createRequests(heatmap_max_keypoint::get_examples_nhwc_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, heatmap_max_keypoint_nchw_2) {
  generated_tests::Execute(device,
                           heatmap_max_keypoint::createTestModel_nchw_2,
                           heatmap_max_keypoint::is_ignored_nchw_2,
                           heatmap_max_keypoint::get_examples_nchw_2());
}

TEST_F(ValidationTest, heatmap_max_keypoint_nchw_2) {
  const Model model = heatmap_max_keypoint::createTestModel_nchw_2();
  const std::vector<Request> requests = createRequests(heatmap_max_keypoint::get_examples_nchw_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, heatmap_max_keypoint_nchw_relaxed_2) {
  generated_tests::Execute(device,
                           heatmap_max_keypoint::createTestModel_nchw_relaxed_2,
                           heatmap_max_keypoint::is_ignored_nchw_relaxed_2,
                           heatmap_max_keypoint::get_examples_nchw_relaxed_2());
}

TEST_F(ValidationTest, heatmap_max_keypoint_nchw_relaxed_2) {
  const Model model = heatmap_max_keypoint::createTestModel_nchw_relaxed_2();
  const std::vector<Request> requests = createRequests(heatmap_max_keypoint::get_examples_nchw_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: l2_normalization_v1_2.mod.py.
namespace l2_normalization_v1_2 {
// Generated l2_normalization_v1_2 test
#include "examples/l2_normalization_v1_2.example.cpp"
// Generated model constructor
#include "vts_models/l2_normalization_v1_2.model.cpp"
} // namespace l2_normalization_v1_2

TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_dim1_axis0) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_dim1_axis0,
                           l2_normalization_v1_2::is_ignored_dim1_axis0,
                           l2_normalization_v1_2::get_examples_dim1_axis0());
}

TEST_F(ValidationTest, l2_normalization_v1_2_dim1_axis0) {
  const Model model = l2_normalization_v1_2::createTestModel_dim1_axis0();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_dim1_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_dim2_axis1) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_dim2_axis1,
                           l2_normalization_v1_2::is_ignored_dim2_axis1,
                           l2_normalization_v1_2::get_examples_dim2_axis1());
}

TEST_F(ValidationTest, l2_normalization_v1_2_dim2_axis1) {
  const Model model = l2_normalization_v1_2::createTestModel_dim2_axis1();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_dim2_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_dim3_axis2) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_dim3_axis2,
                           l2_normalization_v1_2::is_ignored_dim3_axis2,
                           l2_normalization_v1_2::get_examples_dim3_axis2());
}

TEST_F(ValidationTest, l2_normalization_v1_2_dim3_axis2) {
  const Model model = l2_normalization_v1_2::createTestModel_dim3_axis2();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_dim3_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_relaxed_dim1_axis0) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_relaxed_dim1_axis0,
                           l2_normalization_v1_2::is_ignored_relaxed_dim1_axis0,
                           l2_normalization_v1_2::get_examples_relaxed_dim1_axis0());
}

TEST_F(ValidationTest, l2_normalization_v1_2_relaxed_dim1_axis0) {
  const Model model = l2_normalization_v1_2::createTestModel_relaxed_dim1_axis0();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_relaxed_dim1_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_relaxed_dim2_axis1) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_relaxed_dim2_axis1,
                           l2_normalization_v1_2::is_ignored_relaxed_dim2_axis1,
                           l2_normalization_v1_2::get_examples_relaxed_dim2_axis1());
}

TEST_F(ValidationTest, l2_normalization_v1_2_relaxed_dim2_axis1) {
  const Model model = l2_normalization_v1_2::createTestModel_relaxed_dim2_axis1();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_relaxed_dim2_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_relaxed_dim3_axis2) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_relaxed_dim3_axis2,
                           l2_normalization_v1_2::is_ignored_relaxed_dim3_axis2,
                           l2_normalization_v1_2::get_examples_relaxed_dim3_axis2());
}

TEST_F(ValidationTest, l2_normalization_v1_2_relaxed_dim3_axis2) {
  const Model model = l2_normalization_v1_2::createTestModel_relaxed_dim3_axis2();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_relaxed_dim3_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_dim4_axis0) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_dim4_axis0,
                           l2_normalization_v1_2::is_ignored_axis_dim4_axis0,
                           l2_normalization_v1_2::get_examples_axis_dim4_axis0());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_dim4_axis0) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_dim4_axis0();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_dim4_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_dim4_axis0_neg) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_dim4_axis0_neg,
                           l2_normalization_v1_2::is_ignored_axis_dim4_axis0_neg,
                           l2_normalization_v1_2::get_examples_axis_dim4_axis0_neg());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_dim4_axis0_neg) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_dim4_axis0_neg();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_dim4_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_dim4_axis1) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_dim4_axis1,
                           l2_normalization_v1_2::is_ignored_axis_dim4_axis1,
                           l2_normalization_v1_2::get_examples_axis_dim4_axis1());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_dim4_axis1) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_dim4_axis1();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_dim4_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_dim4_axis1_neg) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_dim4_axis1_neg,
                           l2_normalization_v1_2::is_ignored_axis_dim4_axis1_neg,
                           l2_normalization_v1_2::get_examples_axis_dim4_axis1_neg());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_dim4_axis1_neg) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_dim4_axis1_neg();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_dim4_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_dim4_axis2) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_dim4_axis2,
                           l2_normalization_v1_2::is_ignored_axis_dim4_axis2,
                           l2_normalization_v1_2::get_examples_axis_dim4_axis2());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_dim4_axis2) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_dim4_axis2();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_dim4_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_dim4_axis2_neg) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_dim4_axis2_neg,
                           l2_normalization_v1_2::is_ignored_axis_dim4_axis2_neg,
                           l2_normalization_v1_2::get_examples_axis_dim4_axis2_neg());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_dim4_axis2_neg) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_dim4_axis2_neg();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_dim4_axis2_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_dim4_axis3) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_dim4_axis3,
                           l2_normalization_v1_2::is_ignored_axis_dim4_axis3,
                           l2_normalization_v1_2::get_examples_axis_dim4_axis3());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_dim4_axis3) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_dim4_axis3();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_dim4_axis3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_dim4_axis3_neg) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_dim4_axis3_neg,
                           l2_normalization_v1_2::is_ignored_axis_dim4_axis3_neg,
                           l2_normalization_v1_2::get_examples_axis_dim4_axis3_neg());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_dim4_axis3_neg) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_dim4_axis3_neg();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_dim4_axis3_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_dim3_axis0) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_dim3_axis0,
                           l2_normalization_v1_2::is_ignored_axis_dim3_axis0,
                           l2_normalization_v1_2::get_examples_axis_dim3_axis0());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_dim3_axis0) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_dim3_axis0();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_dim3_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_dim3_axis0_neg) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_dim3_axis0_neg,
                           l2_normalization_v1_2::is_ignored_axis_dim3_axis0_neg,
                           l2_normalization_v1_2::get_examples_axis_dim3_axis0_neg());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_dim3_axis0_neg) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_dim3_axis0_neg();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_dim3_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_dim3_axis1) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_dim3_axis1,
                           l2_normalization_v1_2::is_ignored_axis_dim3_axis1,
                           l2_normalization_v1_2::get_examples_axis_dim3_axis1());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_dim3_axis1) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_dim3_axis1();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_dim3_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_dim3_axis1_neg) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_dim3_axis1_neg,
                           l2_normalization_v1_2::is_ignored_axis_dim3_axis1_neg,
                           l2_normalization_v1_2::get_examples_axis_dim3_axis1_neg());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_dim3_axis1_neg) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_dim3_axis1_neg();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_dim3_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_dim3_axis2) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_dim3_axis2,
                           l2_normalization_v1_2::is_ignored_axis_dim3_axis2,
                           l2_normalization_v1_2::get_examples_axis_dim3_axis2());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_dim3_axis2) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_dim3_axis2();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_dim3_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_dim3_axis2_neg) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_dim3_axis2_neg,
                           l2_normalization_v1_2::is_ignored_axis_dim3_axis2_neg,
                           l2_normalization_v1_2::get_examples_axis_dim3_axis2_neg());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_dim3_axis2_neg) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_dim3_axis2_neg();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_dim3_axis2_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_dim2_axis0) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_dim2_axis0,
                           l2_normalization_v1_2::is_ignored_axis_dim2_axis0,
                           l2_normalization_v1_2::get_examples_axis_dim2_axis0());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_dim2_axis0) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_dim2_axis0();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_dim2_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_dim2_axis0_neg) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_dim2_axis0_neg,
                           l2_normalization_v1_2::is_ignored_axis_dim2_axis0_neg,
                           l2_normalization_v1_2::get_examples_axis_dim2_axis0_neg());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_dim2_axis0_neg) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_dim2_axis0_neg();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_dim2_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_dim2_axis1) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_dim2_axis1,
                           l2_normalization_v1_2::is_ignored_axis_dim2_axis1,
                           l2_normalization_v1_2::get_examples_axis_dim2_axis1());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_dim2_axis1) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_dim2_axis1();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_dim2_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_dim2_axis1_neg) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_dim2_axis1_neg,
                           l2_normalization_v1_2::is_ignored_axis_dim2_axis1_neg,
                           l2_normalization_v1_2::get_examples_axis_dim2_axis1_neg());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_dim2_axis1_neg) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_dim2_axis1_neg();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_dim2_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_dim1_axis0) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_dim1_axis0,
                           l2_normalization_v1_2::is_ignored_axis_dim1_axis0,
                           l2_normalization_v1_2::get_examples_axis_dim1_axis0());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_dim1_axis0) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_dim1_axis0();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_dim1_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_dim1_axis0_neg) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_dim1_axis0_neg,
                           l2_normalization_v1_2::is_ignored_axis_dim1_axis0_neg,
                           l2_normalization_v1_2::get_examples_axis_dim1_axis0_neg());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_dim1_axis0_neg) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_dim1_axis0_neg();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_dim1_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_relaxed_dim4_axis0) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis0,
                           l2_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis0,
                           l2_normalization_v1_2::get_examples_axis_relaxed_dim4_axis0());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_relaxed_dim4_axis0) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis0();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_relaxed_dim4_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_relaxed_dim4_axis0_neg) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis0_neg,
                           l2_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis0_neg,
                           l2_normalization_v1_2::get_examples_axis_relaxed_dim4_axis0_neg());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_relaxed_dim4_axis0_neg) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis0_neg();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_relaxed_dim4_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_relaxed_dim4_axis1) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis1,
                           l2_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis1,
                           l2_normalization_v1_2::get_examples_axis_relaxed_dim4_axis1());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_relaxed_dim4_axis1) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis1();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_relaxed_dim4_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_relaxed_dim4_axis1_neg) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis1_neg,
                           l2_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis1_neg,
                           l2_normalization_v1_2::get_examples_axis_relaxed_dim4_axis1_neg());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_relaxed_dim4_axis1_neg) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis1_neg();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_relaxed_dim4_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_relaxed_dim4_axis2) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis2,
                           l2_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis2,
                           l2_normalization_v1_2::get_examples_axis_relaxed_dim4_axis2());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_relaxed_dim4_axis2) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis2();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_relaxed_dim4_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_relaxed_dim4_axis2_neg) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis2_neg,
                           l2_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis2_neg,
                           l2_normalization_v1_2::get_examples_axis_relaxed_dim4_axis2_neg());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_relaxed_dim4_axis2_neg) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis2_neg();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_relaxed_dim4_axis2_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_relaxed_dim4_axis3) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis3,
                           l2_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis3,
                           l2_normalization_v1_2::get_examples_axis_relaxed_dim4_axis3());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_relaxed_dim4_axis3) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis3();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_relaxed_dim4_axis3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_relaxed_dim4_axis3_neg) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis3_neg,
                           l2_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis3_neg,
                           l2_normalization_v1_2::get_examples_axis_relaxed_dim4_axis3_neg());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_relaxed_dim4_axis3_neg) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis3_neg();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_relaxed_dim4_axis3_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_relaxed_dim3_axis0) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis0,
                           l2_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis0,
                           l2_normalization_v1_2::get_examples_axis_relaxed_dim3_axis0());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_relaxed_dim3_axis0) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis0();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_relaxed_dim3_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_relaxed_dim3_axis0_neg) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis0_neg,
                           l2_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis0_neg,
                           l2_normalization_v1_2::get_examples_axis_relaxed_dim3_axis0_neg());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_relaxed_dim3_axis0_neg) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis0_neg();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_relaxed_dim3_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_relaxed_dim3_axis1) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis1,
                           l2_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis1,
                           l2_normalization_v1_2::get_examples_axis_relaxed_dim3_axis1());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_relaxed_dim3_axis1) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis1();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_relaxed_dim3_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_relaxed_dim3_axis1_neg) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis1_neg,
                           l2_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis1_neg,
                           l2_normalization_v1_2::get_examples_axis_relaxed_dim3_axis1_neg());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_relaxed_dim3_axis1_neg) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis1_neg();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_relaxed_dim3_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_relaxed_dim3_axis2) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis2,
                           l2_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis2,
                           l2_normalization_v1_2::get_examples_axis_relaxed_dim3_axis2());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_relaxed_dim3_axis2) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis2();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_relaxed_dim3_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_relaxed_dim3_axis2_neg) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis2_neg,
                           l2_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis2_neg,
                           l2_normalization_v1_2::get_examples_axis_relaxed_dim3_axis2_neg());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_relaxed_dim3_axis2_neg) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis2_neg();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_relaxed_dim3_axis2_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_relaxed_dim2_axis0) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis0,
                           l2_normalization_v1_2::is_ignored_axis_relaxed_dim2_axis0,
                           l2_normalization_v1_2::get_examples_axis_relaxed_dim2_axis0());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_relaxed_dim2_axis0) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis0();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_relaxed_dim2_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_relaxed_dim2_axis0_neg) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis0_neg,
                           l2_normalization_v1_2::is_ignored_axis_relaxed_dim2_axis0_neg,
                           l2_normalization_v1_2::get_examples_axis_relaxed_dim2_axis0_neg());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_relaxed_dim2_axis0_neg) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis0_neg();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_relaxed_dim2_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_relaxed_dim2_axis1) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis1,
                           l2_normalization_v1_2::is_ignored_axis_relaxed_dim2_axis1,
                           l2_normalization_v1_2::get_examples_axis_relaxed_dim2_axis1());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_relaxed_dim2_axis1) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis1();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_relaxed_dim2_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_relaxed_dim2_axis1_neg) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis1_neg,
                           l2_normalization_v1_2::is_ignored_axis_relaxed_dim2_axis1_neg,
                           l2_normalization_v1_2::get_examples_axis_relaxed_dim2_axis1_neg());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_relaxed_dim2_axis1_neg) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis1_neg();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_relaxed_dim2_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_relaxed_dim1_axis0) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_relaxed_dim1_axis0,
                           l2_normalization_v1_2::is_ignored_axis_relaxed_dim1_axis0,
                           l2_normalization_v1_2::get_examples_axis_relaxed_dim1_axis0());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_relaxed_dim1_axis0) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_relaxed_dim1_axis0();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_relaxed_dim1_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_normalization_v1_2_axis_relaxed_dim1_axis0_neg) {
  generated_tests::Execute(device,
                           l2_normalization_v1_2::createTestModel_axis_relaxed_dim1_axis0_neg,
                           l2_normalization_v1_2::is_ignored_axis_relaxed_dim1_axis0_neg,
                           l2_normalization_v1_2::get_examples_axis_relaxed_dim1_axis0_neg());
}

TEST_F(ValidationTest, l2_normalization_v1_2_axis_relaxed_dim1_axis0_neg) {
  const Model model = l2_normalization_v1_2::createTestModel_axis_relaxed_dim1_axis0_neg();
  const std::vector<Request> requests = createRequests(l2_normalization_v1_2::get_examples_axis_relaxed_dim1_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: l2_pool_v1_2.mod.py.
namespace l2_pool_v1_2 {
// Generated l2_pool_v1_2 test
#include "examples/l2_pool_v1_2.example.cpp"
// Generated model constructor
#include "vts_models/l2_pool_v1_2.model.cpp"
} // namespace l2_pool_v1_2

TEST_F(NeuralnetworksHidlTest, l2_pool_v1_2_nhwc) {
  generated_tests::Execute(device,
                           l2_pool_v1_2::createTestModel_nhwc,
                           l2_pool_v1_2::is_ignored_nhwc,
                           l2_pool_v1_2::get_examples_nhwc());
}

TEST_F(ValidationTest, l2_pool_v1_2_nhwc) {
  const Model model = l2_pool_v1_2::createTestModel_nhwc();
  const std::vector<Request> requests = createRequests(l2_pool_v1_2::get_examples_nhwc());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_pool_v1_2_nhwc_relaxed) {
  generated_tests::Execute(device,
                           l2_pool_v1_2::createTestModel_nhwc_relaxed,
                           l2_pool_v1_2::is_ignored_nhwc_relaxed,
                           l2_pool_v1_2::get_examples_nhwc_relaxed());
}

TEST_F(ValidationTest, l2_pool_v1_2_nhwc_relaxed) {
  const Model model = l2_pool_v1_2::createTestModel_nhwc_relaxed();
  const std::vector<Request> requests = createRequests(l2_pool_v1_2::get_examples_nhwc_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_pool_v1_2_nchw) {
  generated_tests::Execute(device,
                           l2_pool_v1_2::createTestModel_nchw,
                           l2_pool_v1_2::is_ignored_nchw,
                           l2_pool_v1_2::get_examples_nchw());
}

TEST_F(ValidationTest, l2_pool_v1_2_nchw) {
  const Model model = l2_pool_v1_2::createTestModel_nchw();
  const std::vector<Request> requests = createRequests(l2_pool_v1_2::get_examples_nchw());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_pool_v1_2_nchw_relaxed) {
  generated_tests::Execute(device,
                           l2_pool_v1_2::createTestModel_nchw_relaxed,
                           l2_pool_v1_2::is_ignored_nchw_relaxed,
                           l2_pool_v1_2::get_examples_nchw_relaxed());
}

TEST_F(ValidationTest, l2_pool_v1_2_nchw_relaxed) {
  const Model model = l2_pool_v1_2::createTestModel_nchw_relaxed();
  const std::vector<Request> requests = createRequests(l2_pool_v1_2::get_examples_nchw_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_pool_v1_2_nhwc_2) {
  generated_tests::Execute(device,
                           l2_pool_v1_2::createTestModel_nhwc_2,
                           l2_pool_v1_2::is_ignored_nhwc_2,
                           l2_pool_v1_2::get_examples_nhwc_2());
}

TEST_F(ValidationTest, l2_pool_v1_2_nhwc_2) {
  const Model model = l2_pool_v1_2::createTestModel_nhwc_2();
  const std::vector<Request> requests = createRequests(l2_pool_v1_2::get_examples_nhwc_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_pool_v1_2_nhwc_relaxed_2) {
  generated_tests::Execute(device,
                           l2_pool_v1_2::createTestModel_nhwc_relaxed_2,
                           l2_pool_v1_2::is_ignored_nhwc_relaxed_2,
                           l2_pool_v1_2::get_examples_nhwc_relaxed_2());
}

TEST_F(ValidationTest, l2_pool_v1_2_nhwc_relaxed_2) {
  const Model model = l2_pool_v1_2::createTestModel_nhwc_relaxed_2();
  const std::vector<Request> requests = createRequests(l2_pool_v1_2::get_examples_nhwc_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_pool_v1_2_nchw_2) {
  generated_tests::Execute(device,
                           l2_pool_v1_2::createTestModel_nchw_2,
                           l2_pool_v1_2::is_ignored_nchw_2,
                           l2_pool_v1_2::get_examples_nchw_2());
}

TEST_F(ValidationTest, l2_pool_v1_2_nchw_2) {
  const Model model = l2_pool_v1_2::createTestModel_nchw_2();
  const std::vector<Request> requests = createRequests(l2_pool_v1_2::get_examples_nchw_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_pool_v1_2_nchw_relaxed_2) {
  generated_tests::Execute(device,
                           l2_pool_v1_2::createTestModel_nchw_relaxed_2,
                           l2_pool_v1_2::is_ignored_nchw_relaxed_2,
                           l2_pool_v1_2::get_examples_nchw_relaxed_2());
}

TEST_F(ValidationTest, l2_pool_v1_2_nchw_relaxed_2) {
  const Model model = l2_pool_v1_2::createTestModel_nchw_relaxed_2();
  const std::vector<Request> requests = createRequests(l2_pool_v1_2::get_examples_nchw_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_pool_v1_2_large_nhwc) {
  generated_tests::Execute(device,
                           l2_pool_v1_2::createTestModel_large_nhwc,
                           l2_pool_v1_2::is_ignored_large_nhwc,
                           l2_pool_v1_2::get_examples_large_nhwc());
}

TEST_F(ValidationTest, l2_pool_v1_2_large_nhwc) {
  const Model model = l2_pool_v1_2::createTestModel_large_nhwc();
  const std::vector<Request> requests = createRequests(l2_pool_v1_2::get_examples_large_nhwc());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_pool_v1_2_large_nhwc_relaxed) {
  generated_tests::Execute(device,
                           l2_pool_v1_2::createTestModel_large_nhwc_relaxed,
                           l2_pool_v1_2::is_ignored_large_nhwc_relaxed,
                           l2_pool_v1_2::get_examples_large_nhwc_relaxed());
}

TEST_F(ValidationTest, l2_pool_v1_2_large_nhwc_relaxed) {
  const Model model = l2_pool_v1_2::createTestModel_large_nhwc_relaxed();
  const std::vector<Request> requests = createRequests(l2_pool_v1_2::get_examples_large_nhwc_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_pool_v1_2_large_nchw) {
  generated_tests::Execute(device,
                           l2_pool_v1_2::createTestModel_large_nchw,
                           l2_pool_v1_2::is_ignored_large_nchw,
                           l2_pool_v1_2::get_examples_large_nchw());
}

TEST_F(ValidationTest, l2_pool_v1_2_large_nchw) {
  const Model model = l2_pool_v1_2::createTestModel_large_nchw();
  const std::vector<Request> requests = createRequests(l2_pool_v1_2::get_examples_large_nchw());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, l2_pool_v1_2_large_nchw_relaxed) {
  generated_tests::Execute(device,
                           l2_pool_v1_2::createTestModel_large_nchw_relaxed,
                           l2_pool_v1_2::is_ignored_large_nchw_relaxed,
                           l2_pool_v1_2::get_examples_large_nchw_relaxed());
}

TEST_F(ValidationTest, l2_pool_v1_2_large_nchw_relaxed) {
  const Model model = l2_pool_v1_2::createTestModel_large_nchw_relaxed();
  const std::vector<Request> requests = createRequests(l2_pool_v1_2::get_examples_large_nchw_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: layer_norm_lstm.mod.py.
namespace layer_norm_lstm {
// Generated layer_norm_lstm test
#include "examples/layer_norm_lstm.example.cpp"
// Generated model constructor
#include "vts_models/layer_norm_lstm.model.cpp"
} // namespace layer_norm_lstm

TEST_F(NeuralnetworksHidlTest, layer_norm_lstm) {
  generated_tests::Execute(device,
                           layer_norm_lstm::createTestModel,
                           layer_norm_lstm::is_ignored,
                           layer_norm_lstm::get_examples());
}

TEST_F(ValidationTest, layer_norm_lstm) {
  const Model model = layer_norm_lstm::createTestModel();
  const std::vector<Request> requests = createRequests(layer_norm_lstm::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: local_response_normalization_v1_2.mod.py.
namespace local_response_normalization_v1_2 {
// Generated local_response_normalization_v1_2 test
#include "examples/local_response_normalization_v1_2.example.cpp"
// Generated model constructor
#include "vts_models/local_response_normalization_v1_2.model.cpp"
} // namespace local_response_normalization_v1_2

TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis0) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis0,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis0,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis0());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis0) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis0();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis0_neg) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis0_neg,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis0_neg,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis0_neg());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis0_neg) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis0_neg();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis1) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis1,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis1,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis1());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis1) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis1();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis1_neg) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis1_neg,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis1_neg,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis1_neg());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis1_neg) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis1_neg();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis2,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis2,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis2_neg) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis2_neg,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis2_neg,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis2_neg());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis2_neg) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis2_neg();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis2_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis3,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis3,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis3_neg) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis3_neg,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis3_neg,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis3_neg());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis3_neg) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis3_neg();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis3_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim3_axis0) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim3_axis0,
                           local_response_normalization_v1_2::is_ignored_axis_dim3_axis0,
                           local_response_normalization_v1_2::get_examples_axis_dim3_axis0());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim3_axis0) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim3_axis0();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim3_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim3_axis0_neg) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim3_axis0_neg,
                           local_response_normalization_v1_2::is_ignored_axis_dim3_axis0_neg,
                           local_response_normalization_v1_2::get_examples_axis_dim3_axis0_neg());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim3_axis0_neg) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim3_axis0_neg();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim3_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim3_axis1) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim3_axis1,
                           local_response_normalization_v1_2::is_ignored_axis_dim3_axis1,
                           local_response_normalization_v1_2::get_examples_axis_dim3_axis1());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim3_axis1) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim3_axis1();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim3_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim3_axis1_neg) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim3_axis1_neg,
                           local_response_normalization_v1_2::is_ignored_axis_dim3_axis1_neg,
                           local_response_normalization_v1_2::get_examples_axis_dim3_axis1_neg());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim3_axis1_neg) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim3_axis1_neg();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim3_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim3_axis2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim3_axis2,
                           local_response_normalization_v1_2::is_ignored_axis_dim3_axis2,
                           local_response_normalization_v1_2::get_examples_axis_dim3_axis2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim3_axis2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim3_axis2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim3_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim3_axis2_neg) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim3_axis2_neg,
                           local_response_normalization_v1_2::is_ignored_axis_dim3_axis2_neg,
                           local_response_normalization_v1_2::get_examples_axis_dim3_axis2_neg());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim3_axis2_neg) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim3_axis2_neg();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim3_axis2_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim2_axis0) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim2_axis0,
                           local_response_normalization_v1_2::is_ignored_axis_dim2_axis0,
                           local_response_normalization_v1_2::get_examples_axis_dim2_axis0());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim2_axis0) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim2_axis0();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim2_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim2_axis0_neg) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim2_axis0_neg,
                           local_response_normalization_v1_2::is_ignored_axis_dim2_axis0_neg,
                           local_response_normalization_v1_2::get_examples_axis_dim2_axis0_neg());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim2_axis0_neg) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim2_axis0_neg();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim2_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim2_axis1) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim2_axis1,
                           local_response_normalization_v1_2::is_ignored_axis_dim2_axis1,
                           local_response_normalization_v1_2::get_examples_axis_dim2_axis1());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim2_axis1) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim2_axis1();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim2_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim2_axis1_neg) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim2_axis1_neg,
                           local_response_normalization_v1_2::is_ignored_axis_dim2_axis1_neg,
                           local_response_normalization_v1_2::get_examples_axis_dim2_axis1_neg());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim2_axis1_neg) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim2_axis1_neg();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim2_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim1_axis0) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim1_axis0,
                           local_response_normalization_v1_2::is_ignored_axis_dim1_axis0,
                           local_response_normalization_v1_2::get_examples_axis_dim1_axis0());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim1_axis0) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim1_axis0();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim1_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim1_axis0_neg) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim1_axis0_neg,
                           local_response_normalization_v1_2::is_ignored_axis_dim1_axis0_neg,
                           local_response_normalization_v1_2::get_examples_axis_dim1_axis0_neg());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim1_axis0_neg) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim1_axis0_neg();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim1_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis0) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis0,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis0,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis0());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis0) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis0();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis0_neg) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis0_neg,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis0_neg,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis0_neg());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis0_neg) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis0_neg();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis1) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis1,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis1,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis1());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis1) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis1();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis1_neg) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis1_neg,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis1_neg,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis1_neg());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis1_neg) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis1_neg();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis2,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis2,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis2_neg) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis2_neg,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis2_neg,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis2_neg());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis2_neg) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis2_neg();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis2_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis3,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis3,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis3_neg) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis3_neg,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis3_neg,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis3_neg());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis3_neg) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis3_neg();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis3_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis0) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis0,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis0,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis0());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis0) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis0();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis0_neg) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis0_neg,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis0_neg,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis0_neg());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis0_neg) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis0_neg();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis1) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis1,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis1,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis1());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis1) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis1();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis1_neg) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis1_neg,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis1_neg,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis1_neg());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis1_neg) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis1_neg();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis2,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis2,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis2_neg) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis2_neg,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis2_neg,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis2_neg());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis2_neg) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis2_neg();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis2_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis0) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis0,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim2_axis0,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis0());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis0) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis0();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis0_neg) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis0_neg,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim2_axis0_neg,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis0_neg());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis0_neg) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis0_neg();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis1) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis1,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim2_axis1,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis1());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis1) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis1();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis1_neg) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis1_neg,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim2_axis1_neg,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis1_neg());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis1_neg) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis1_neg();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim1_axis0) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim1_axis0,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim1_axis0,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim1_axis0());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim1_axis0) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim1_axis0();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim1_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim1_axis0_neg) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim1_axis0_neg,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim1_axis0_neg,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim1_axis0_neg());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim1_axis0_neg) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim1_axis0_neg();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim1_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis0_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis0_2,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis0_2,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis0_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis0_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis0_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis0_neg_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis0_neg_2,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis0_neg_2,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis0_neg_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis0_neg_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis0_neg_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis1_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis1_2,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis1_2,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis1_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis1_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis1_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis1_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis1_neg_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis1_neg_2,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis1_neg_2,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis1_neg_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis1_neg_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis1_neg_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis1_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis2_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis2_2,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis2_2,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis2_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis2_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis2_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis2_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis2_neg_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis2_neg_2,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis2_neg_2,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis2_neg_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis2_neg_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis2_neg_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis2_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis3_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis3_2,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis3_2,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis3_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis3_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis3_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis3_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis3_neg_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis3_neg_2,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis3_neg_2,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis3_neg_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis3_neg_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis3_neg_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis3_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim3_axis0_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim3_axis0_2,
                           local_response_normalization_v1_2::is_ignored_axis_dim3_axis0_2,
                           local_response_normalization_v1_2::get_examples_axis_dim3_axis0_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim3_axis0_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim3_axis0_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim3_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim3_axis0_neg_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim3_axis0_neg_2,
                           local_response_normalization_v1_2::is_ignored_axis_dim3_axis0_neg_2,
                           local_response_normalization_v1_2::get_examples_axis_dim3_axis0_neg_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim3_axis0_neg_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim3_axis0_neg_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim3_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim3_axis1_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim3_axis1_2,
                           local_response_normalization_v1_2::is_ignored_axis_dim3_axis1_2,
                           local_response_normalization_v1_2::get_examples_axis_dim3_axis1_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim3_axis1_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim3_axis1_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim3_axis1_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim3_axis1_neg_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim3_axis1_neg_2,
                           local_response_normalization_v1_2::is_ignored_axis_dim3_axis1_neg_2,
                           local_response_normalization_v1_2::get_examples_axis_dim3_axis1_neg_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim3_axis1_neg_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim3_axis1_neg_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim3_axis1_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim3_axis2_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim3_axis2_2,
                           local_response_normalization_v1_2::is_ignored_axis_dim3_axis2_2,
                           local_response_normalization_v1_2::get_examples_axis_dim3_axis2_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim3_axis2_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim3_axis2_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim3_axis2_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim3_axis2_neg_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim3_axis2_neg_2,
                           local_response_normalization_v1_2::is_ignored_axis_dim3_axis2_neg_2,
                           local_response_normalization_v1_2::get_examples_axis_dim3_axis2_neg_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim3_axis2_neg_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim3_axis2_neg_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim3_axis2_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim2_axis0_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim2_axis0_2,
                           local_response_normalization_v1_2::is_ignored_axis_dim2_axis0_2,
                           local_response_normalization_v1_2::get_examples_axis_dim2_axis0_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim2_axis0_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim2_axis0_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim2_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim2_axis0_neg_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim2_axis0_neg_2,
                           local_response_normalization_v1_2::is_ignored_axis_dim2_axis0_neg_2,
                           local_response_normalization_v1_2::get_examples_axis_dim2_axis0_neg_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim2_axis0_neg_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim2_axis0_neg_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim2_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim2_axis1_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim2_axis1_2,
                           local_response_normalization_v1_2::is_ignored_axis_dim2_axis1_2,
                           local_response_normalization_v1_2::get_examples_axis_dim2_axis1_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim2_axis1_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim2_axis1_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim2_axis1_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim2_axis1_neg_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim2_axis1_neg_2,
                           local_response_normalization_v1_2::is_ignored_axis_dim2_axis1_neg_2,
                           local_response_normalization_v1_2::get_examples_axis_dim2_axis1_neg_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim2_axis1_neg_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim2_axis1_neg_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim2_axis1_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim1_axis0_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim1_axis0_2,
                           local_response_normalization_v1_2::is_ignored_axis_dim1_axis0_2,
                           local_response_normalization_v1_2::get_examples_axis_dim1_axis0_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim1_axis0_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim1_axis0_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim1_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim1_axis0_neg_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim1_axis0_neg_2,
                           local_response_normalization_v1_2::is_ignored_axis_dim1_axis0_neg_2,
                           local_response_normalization_v1_2::get_examples_axis_dim1_axis0_neg_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim1_axis0_neg_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim1_axis0_neg_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim1_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis0_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis0_2,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis0_2,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis0_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis0_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis0_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis0_neg_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis0_neg_2,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis0_neg_2,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis0_neg_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis0_neg_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis0_neg_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis1_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis1_2,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis1_2,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis1_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis1_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis1_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis1_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis1_neg_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis1_neg_2,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis1_neg_2,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis1_neg_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis1_neg_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis1_neg_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis1_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis2_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis2_2,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis2_2,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis2_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis2_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis2_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis2_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis2_neg_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis2_neg_2,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis2_neg_2,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis2_neg_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis2_neg_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis2_neg_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis2_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis3_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis3_2,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis3_2,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis3_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis3_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis3_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis3_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis3_neg_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis3_neg_2,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis3_neg_2,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis3_neg_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis3_neg_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis3_neg_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis3_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis0_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis0_2,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis0_2,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis0_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis0_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis0_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis0_neg_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis0_neg_2,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis0_neg_2,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis0_neg_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis0_neg_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis0_neg_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis1_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis1_2,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis1_2,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis1_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis1_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis1_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis1_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis1_neg_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis1_neg_2,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis1_neg_2,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis1_neg_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis1_neg_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis1_neg_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis1_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis2_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis2_2,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis2_2,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis2_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis2_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis2_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis2_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis2_neg_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis2_neg_2,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis2_neg_2,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis2_neg_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis2_neg_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis2_neg_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis2_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis0_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis0_2,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim2_axis0_2,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis0_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis0_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis0_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis0_neg_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis0_neg_2,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim2_axis0_neg_2,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis0_neg_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis0_neg_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis0_neg_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis1_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis1_2,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim2_axis1_2,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis1_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis1_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis1_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis1_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis1_neg_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis1_neg_2,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim2_axis1_neg_2,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis1_neg_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis1_neg_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis1_neg_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis1_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim1_axis0_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim1_axis0_2,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim1_axis0_2,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim1_axis0_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim1_axis0_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim1_axis0_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim1_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim1_axis0_neg_2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim1_axis0_neg_2,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim1_axis0_neg_2,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim1_axis0_neg_2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim1_axis0_neg_2) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim1_axis0_neg_2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim1_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis0_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis0_3,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis0_3,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis0_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis0_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis0_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis0_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis0_neg_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis0_neg_3,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis0_neg_3,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis0_neg_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis0_neg_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis0_neg_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis0_neg_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis1_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis1_3,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis1_3,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis1_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis1_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis1_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis1_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis1_neg_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis1_neg_3,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis1_neg_3,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis1_neg_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis1_neg_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis1_neg_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis1_neg_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis2_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis2_3,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis2_3,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis2_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis2_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis2_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis2_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis2_neg_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis2_neg_3,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis2_neg_3,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis2_neg_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis2_neg_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis2_neg_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis2_neg_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis3_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis3_3,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis3_3,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis3_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis3_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis3_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis3_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim4_axis3_neg_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim4_axis3_neg_3,
                           local_response_normalization_v1_2::is_ignored_axis_dim4_axis3_neg_3,
                           local_response_normalization_v1_2::get_examples_axis_dim4_axis3_neg_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim4_axis3_neg_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim4_axis3_neg_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim4_axis3_neg_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim3_axis0_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim3_axis0_3,
                           local_response_normalization_v1_2::is_ignored_axis_dim3_axis0_3,
                           local_response_normalization_v1_2::get_examples_axis_dim3_axis0_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim3_axis0_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim3_axis0_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim3_axis0_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim3_axis0_neg_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim3_axis0_neg_3,
                           local_response_normalization_v1_2::is_ignored_axis_dim3_axis0_neg_3,
                           local_response_normalization_v1_2::get_examples_axis_dim3_axis0_neg_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim3_axis0_neg_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim3_axis0_neg_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim3_axis0_neg_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim3_axis1_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim3_axis1_3,
                           local_response_normalization_v1_2::is_ignored_axis_dim3_axis1_3,
                           local_response_normalization_v1_2::get_examples_axis_dim3_axis1_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim3_axis1_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim3_axis1_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim3_axis1_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim3_axis1_neg_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim3_axis1_neg_3,
                           local_response_normalization_v1_2::is_ignored_axis_dim3_axis1_neg_3,
                           local_response_normalization_v1_2::get_examples_axis_dim3_axis1_neg_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim3_axis1_neg_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim3_axis1_neg_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim3_axis1_neg_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim3_axis2_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim3_axis2_3,
                           local_response_normalization_v1_2::is_ignored_axis_dim3_axis2_3,
                           local_response_normalization_v1_2::get_examples_axis_dim3_axis2_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim3_axis2_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim3_axis2_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim3_axis2_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim3_axis2_neg_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim3_axis2_neg_3,
                           local_response_normalization_v1_2::is_ignored_axis_dim3_axis2_neg_3,
                           local_response_normalization_v1_2::get_examples_axis_dim3_axis2_neg_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim3_axis2_neg_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim3_axis2_neg_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim3_axis2_neg_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim2_axis0_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim2_axis0_3,
                           local_response_normalization_v1_2::is_ignored_axis_dim2_axis0_3,
                           local_response_normalization_v1_2::get_examples_axis_dim2_axis0_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim2_axis0_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim2_axis0_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim2_axis0_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim2_axis0_neg_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim2_axis0_neg_3,
                           local_response_normalization_v1_2::is_ignored_axis_dim2_axis0_neg_3,
                           local_response_normalization_v1_2::get_examples_axis_dim2_axis0_neg_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim2_axis0_neg_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim2_axis0_neg_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim2_axis0_neg_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim2_axis1_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim2_axis1_3,
                           local_response_normalization_v1_2::is_ignored_axis_dim2_axis1_3,
                           local_response_normalization_v1_2::get_examples_axis_dim2_axis1_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim2_axis1_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim2_axis1_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim2_axis1_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim2_axis1_neg_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim2_axis1_neg_3,
                           local_response_normalization_v1_2::is_ignored_axis_dim2_axis1_neg_3,
                           local_response_normalization_v1_2::get_examples_axis_dim2_axis1_neg_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim2_axis1_neg_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim2_axis1_neg_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim2_axis1_neg_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim1_axis0_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim1_axis0_3,
                           local_response_normalization_v1_2::is_ignored_axis_dim1_axis0_3,
                           local_response_normalization_v1_2::get_examples_axis_dim1_axis0_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim1_axis0_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim1_axis0_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim1_axis0_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_dim1_axis0_neg_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_dim1_axis0_neg_3,
                           local_response_normalization_v1_2::is_ignored_axis_dim1_axis0_neg_3,
                           local_response_normalization_v1_2::get_examples_axis_dim1_axis0_neg_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_dim1_axis0_neg_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_dim1_axis0_neg_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_dim1_axis0_neg_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis0_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis0_3,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis0_3,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis0_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis0_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis0_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis0_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis0_neg_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis0_neg_3,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis0_neg_3,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis0_neg_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis0_neg_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis0_neg_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis0_neg_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis1_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis1_3,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis1_3,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis1_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis1_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis1_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis1_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis1_neg_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis1_neg_3,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis1_neg_3,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis1_neg_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis1_neg_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis1_neg_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis1_neg_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis2_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis2_3,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis2_3,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis2_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis2_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis2_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis2_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis2_neg_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis2_neg_3,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis2_neg_3,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis2_neg_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis2_neg_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis2_neg_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis2_neg_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis3_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis3_3,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis3_3,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis3_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis3_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis3_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis3_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis3_neg_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis3_neg_3,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim4_axis3_neg_3,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis3_neg_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim4_axis3_neg_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim4_axis3_neg_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim4_axis3_neg_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis0_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis0_3,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis0_3,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis0_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis0_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis0_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis0_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis0_neg_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis0_neg_3,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis0_neg_3,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis0_neg_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis0_neg_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis0_neg_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis0_neg_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis1_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis1_3,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis1_3,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis1_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis1_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis1_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis1_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis1_neg_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis1_neg_3,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis1_neg_3,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis1_neg_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis1_neg_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis1_neg_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis1_neg_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis2_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis2_3,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis2_3,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis2_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis2_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis2_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis2_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis2_neg_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis2_neg_3,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim3_axis2_neg_3,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis2_neg_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim3_axis2_neg_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim3_axis2_neg_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim3_axis2_neg_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis0_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis0_3,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim2_axis0_3,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis0_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis0_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis0_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis0_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis0_neg_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis0_neg_3,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim2_axis0_neg_3,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis0_neg_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis0_neg_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis0_neg_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis0_neg_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis1_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis1_3,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim2_axis1_3,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis1_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis1_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis1_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis1_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis1_neg_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis1_neg_3,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim2_axis1_neg_3,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis1_neg_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim2_axis1_neg_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim2_axis1_neg_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim2_axis1_neg_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim1_axis0_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim1_axis0_3,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim1_axis0_3,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim1_axis0_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim1_axis0_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim1_axis0_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim1_axis0_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_axis_relaxed_dim1_axis0_neg_3) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_axis_relaxed_dim1_axis0_neg_3,
                           local_response_normalization_v1_2::is_ignored_axis_relaxed_dim1_axis0_neg_3,
                           local_response_normalization_v1_2::get_examples_axis_relaxed_dim1_axis0_neg_3());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_axis_relaxed_dim1_axis0_neg_3) {
  const Model model = local_response_normalization_v1_2::createTestModel_axis_relaxed_dim1_axis0_neg_3();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_axis_relaxed_dim1_axis0_neg_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_dim1_axis0) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_dim1_axis0,
                           local_response_normalization_v1_2::is_ignored_dim1_axis0,
                           local_response_normalization_v1_2::get_examples_dim1_axis0());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_dim1_axis0) {
  const Model model = local_response_normalization_v1_2::createTestModel_dim1_axis0();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_dim1_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_dim2_axis1) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_dim2_axis1,
                           local_response_normalization_v1_2::is_ignored_dim2_axis1,
                           local_response_normalization_v1_2::get_examples_dim2_axis1());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_dim2_axis1) {
  const Model model = local_response_normalization_v1_2::createTestModel_dim2_axis1();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_dim2_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_dim3_axis2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_dim3_axis2,
                           local_response_normalization_v1_2::is_ignored_dim3_axis2,
                           local_response_normalization_v1_2::get_examples_dim3_axis2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_dim3_axis2) {
  const Model model = local_response_normalization_v1_2::createTestModel_dim3_axis2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_dim3_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_relaxed_dim1_axis0) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_relaxed_dim1_axis0,
                           local_response_normalization_v1_2::is_ignored_relaxed_dim1_axis0,
                           local_response_normalization_v1_2::get_examples_relaxed_dim1_axis0());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_relaxed_dim1_axis0) {
  const Model model = local_response_normalization_v1_2::createTestModel_relaxed_dim1_axis0();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_relaxed_dim1_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_relaxed_dim2_axis1) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_relaxed_dim2_axis1,
                           local_response_normalization_v1_2::is_ignored_relaxed_dim2_axis1,
                           local_response_normalization_v1_2::get_examples_relaxed_dim2_axis1());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_relaxed_dim2_axis1) {
  const Model model = local_response_normalization_v1_2::createTestModel_relaxed_dim2_axis1();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_relaxed_dim2_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, local_response_normalization_v1_2_relaxed_dim3_axis2) {
  generated_tests::Execute(device,
                           local_response_normalization_v1_2::createTestModel_relaxed_dim3_axis2,
                           local_response_normalization_v1_2::is_ignored_relaxed_dim3_axis2,
                           local_response_normalization_v1_2::get_examples_relaxed_dim3_axis2());
}

TEST_F(ValidationTest, local_response_normalization_v1_2_relaxed_dim3_axis2) {
  const Model model = local_response_normalization_v1_2::createTestModel_relaxed_dim3_axis2();
  const std::vector<Request> requests = createRequests(local_response_normalization_v1_2::get_examples_relaxed_dim3_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: logistic_float16_1.mod.py.
namespace logistic_float16_1 {
// Generated logistic_float16_1 test
#include "examples/logistic_float16_1.example.cpp"
// Generated model constructor
#include "vts_models/logistic_float16_1.model.cpp"
} // namespace logistic_float16_1

TEST_F(NeuralnetworksHidlTest, logistic_float16_1) {
  generated_tests::Execute(device,
                           logistic_float16_1::createTestModel,
                           logistic_float16_1::is_ignored,
                           logistic_float16_1::get_examples());
}

TEST_F(ValidationTest, logistic_float16_1) {
  const Model model = logistic_float16_1::createTestModel();
  const std::vector<Request> requests = createRequests(logistic_float16_1::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: logistic_float16_2.mod.py.
namespace logistic_float16_2 {
// Generated logistic_float16_2 test
#include "examples/logistic_float16_2.example.cpp"
// Generated model constructor
#include "vts_models/logistic_float16_2.model.cpp"
} // namespace logistic_float16_2

TEST_F(NeuralnetworksHidlTest, logistic_float16_2) {
  generated_tests::Execute(device,
                           logistic_float16_2::createTestModel,
                           logistic_float16_2::is_ignored,
                           logistic_float16_2::get_examples());
}

TEST_F(ValidationTest, logistic_float16_2) {
  const Model model = logistic_float16_2::createTestModel();
  const std::vector<Request> requests = createRequests(logistic_float16_2::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: lsh_projection_3_relaxed.mod.py.
namespace lsh_projection_3_relaxed {
// Generated lsh_projection_3_relaxed test
#include "examples/lsh_projection_3_relaxed.example.cpp"
// Generated model constructor
#include "vts_models/lsh_projection_3_relaxed.model.cpp"
} // namespace lsh_projection_3_relaxed

TEST_F(NeuralnetworksHidlTest, lsh_projection_3_relaxed) {
  generated_tests::Execute(device,
                           lsh_projection_3_relaxed::createTestModel,
                           lsh_projection_3_relaxed::is_ignored,
                           lsh_projection_3_relaxed::get_examples());
}

TEST_F(ValidationTest, lsh_projection_3_relaxed) {
  const Model model = lsh_projection_3_relaxed::createTestModel();
  const std::vector<Request> requests = createRequests(lsh_projection_3_relaxed::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: lsh_projection_4_relaxed.mod.py.
namespace lsh_projection_4_relaxed {
// Generated lsh_projection_4_relaxed test
#include "examples/lsh_projection_4_relaxed.example.cpp"
// Generated model constructor
#include "vts_models/lsh_projection_4_relaxed.model.cpp"
} // namespace lsh_projection_4_relaxed

TEST_F(NeuralnetworksHidlTest, lsh_projection_4_relaxed) {
  generated_tests::Execute(device,
                           lsh_projection_4_relaxed::createTestModel,
                           lsh_projection_4_relaxed::is_ignored,
                           lsh_projection_4_relaxed::get_examples());
}

TEST_F(ValidationTest, lsh_projection_4_relaxed) {
  const Model model = lsh_projection_4_relaxed::createTestModel();
  const std::vector<Request> requests = createRequests(lsh_projection_4_relaxed::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: lsh_projection_deprecated.mod.py.
namespace lsh_projection_deprecated {
// Generated lsh_projection_deprecated test
#include "examples/lsh_projection_deprecated.example.cpp"
// Generated model constructor
#include "vts_models/lsh_projection_deprecated.model.cpp"
} // namespace lsh_projection_deprecated

TEST_F(NeuralnetworksHidlTest, lsh_projection_deprecated) {
  generated_tests::Execute(device,
                           lsh_projection_deprecated::createTestModel,
                           lsh_projection_deprecated::is_ignored,
                           lsh_projection_deprecated::get_examples());
}

TEST_F(ValidationTest, lsh_projection_deprecated) {
  const Model model = lsh_projection_deprecated::createTestModel();
  const std::vector<Request> requests = createRequests(lsh_projection_deprecated::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: max_pool_v1_2.mod.py.
namespace max_pool_v1_2 {
// Generated max_pool_v1_2 test
#include "examples/max_pool_v1_2.example.cpp"
// Generated model constructor
#include "vts_models/max_pool_v1_2.model.cpp"
} // namespace max_pool_v1_2

TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nhwc) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nhwc,
                           max_pool_v1_2::is_ignored_nhwc,
                           max_pool_v1_2::get_examples_nhwc());
}

TEST_F(ValidationTest, max_pool_v1_2_nhwc) {
  const Model model = max_pool_v1_2::createTestModel_nhwc();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nhwc());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nhwc_relaxed) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nhwc_relaxed,
                           max_pool_v1_2::is_ignored_nhwc_relaxed,
                           max_pool_v1_2::get_examples_nhwc_relaxed());
}

TEST_F(ValidationTest, max_pool_v1_2_nhwc_relaxed) {
  const Model model = max_pool_v1_2::createTestModel_nhwc_relaxed();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nhwc_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nhwc_quant8) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nhwc_quant8,
                           max_pool_v1_2::is_ignored_nhwc_quant8,
                           max_pool_v1_2::get_examples_nhwc_quant8());
}

TEST_F(ValidationTest, max_pool_v1_2_nhwc_quant8) {
  const Model model = max_pool_v1_2::createTestModel_nhwc_quant8();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nhwc_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nchw) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nchw,
                           max_pool_v1_2::is_ignored_nchw,
                           max_pool_v1_2::get_examples_nchw());
}

TEST_F(ValidationTest, max_pool_v1_2_nchw) {
  const Model model = max_pool_v1_2::createTestModel_nchw();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nchw());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nchw_relaxed) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nchw_relaxed,
                           max_pool_v1_2::is_ignored_nchw_relaxed,
                           max_pool_v1_2::get_examples_nchw_relaxed());
}

TEST_F(ValidationTest, max_pool_v1_2_nchw_relaxed) {
  const Model model = max_pool_v1_2::createTestModel_nchw_relaxed();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nchw_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nchw_quant8) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nchw_quant8,
                           max_pool_v1_2::is_ignored_nchw_quant8,
                           max_pool_v1_2::get_examples_nchw_quant8());
}

TEST_F(ValidationTest, max_pool_v1_2_nchw_quant8) {
  const Model model = max_pool_v1_2::createTestModel_nchw_quant8();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nchw_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nhwc_2) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nhwc_2,
                           max_pool_v1_2::is_ignored_nhwc_2,
                           max_pool_v1_2::get_examples_nhwc_2());
}

TEST_F(ValidationTest, max_pool_v1_2_nhwc_2) {
  const Model model = max_pool_v1_2::createTestModel_nhwc_2();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nhwc_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nhwc_relaxed_2) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nhwc_relaxed_2,
                           max_pool_v1_2::is_ignored_nhwc_relaxed_2,
                           max_pool_v1_2::get_examples_nhwc_relaxed_2());
}

TEST_F(ValidationTest, max_pool_v1_2_nhwc_relaxed_2) {
  const Model model = max_pool_v1_2::createTestModel_nhwc_relaxed_2();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nhwc_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nhwc_quant8_2) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nhwc_quant8_2,
                           max_pool_v1_2::is_ignored_nhwc_quant8_2,
                           max_pool_v1_2::get_examples_nhwc_quant8_2());
}

TEST_F(ValidationTest, max_pool_v1_2_nhwc_quant8_2) {
  const Model model = max_pool_v1_2::createTestModel_nhwc_quant8_2();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nhwc_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nchw_2) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nchw_2,
                           max_pool_v1_2::is_ignored_nchw_2,
                           max_pool_v1_2::get_examples_nchw_2());
}

TEST_F(ValidationTest, max_pool_v1_2_nchw_2) {
  const Model model = max_pool_v1_2::createTestModel_nchw_2();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nchw_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nchw_relaxed_2) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nchw_relaxed_2,
                           max_pool_v1_2::is_ignored_nchw_relaxed_2,
                           max_pool_v1_2::get_examples_nchw_relaxed_2());
}

TEST_F(ValidationTest, max_pool_v1_2_nchw_relaxed_2) {
  const Model model = max_pool_v1_2::createTestModel_nchw_relaxed_2();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nchw_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nchw_quant8_2) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nchw_quant8_2,
                           max_pool_v1_2::is_ignored_nchw_quant8_2,
                           max_pool_v1_2::get_examples_nchw_quant8_2());
}

TEST_F(ValidationTest, max_pool_v1_2_nchw_quant8_2) {
  const Model model = max_pool_v1_2::createTestModel_nchw_quant8_2();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nchw_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nhwc_3) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nhwc_3,
                           max_pool_v1_2::is_ignored_nhwc_3,
                           max_pool_v1_2::get_examples_nhwc_3());
}

TEST_F(ValidationTest, max_pool_v1_2_nhwc_3) {
  const Model model = max_pool_v1_2::createTestModel_nhwc_3();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nhwc_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nhwc_relaxed_3) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nhwc_relaxed_3,
                           max_pool_v1_2::is_ignored_nhwc_relaxed_3,
                           max_pool_v1_2::get_examples_nhwc_relaxed_3());
}

TEST_F(ValidationTest, max_pool_v1_2_nhwc_relaxed_3) {
  const Model model = max_pool_v1_2::createTestModel_nhwc_relaxed_3();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nhwc_relaxed_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nhwc_quant8_3) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nhwc_quant8_3,
                           max_pool_v1_2::is_ignored_nhwc_quant8_3,
                           max_pool_v1_2::get_examples_nhwc_quant8_3());
}

TEST_F(ValidationTest, max_pool_v1_2_nhwc_quant8_3) {
  const Model model = max_pool_v1_2::createTestModel_nhwc_quant8_3();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nhwc_quant8_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nchw_3) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nchw_3,
                           max_pool_v1_2::is_ignored_nchw_3,
                           max_pool_v1_2::get_examples_nchw_3());
}

TEST_F(ValidationTest, max_pool_v1_2_nchw_3) {
  const Model model = max_pool_v1_2::createTestModel_nchw_3();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nchw_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nchw_relaxed_3) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nchw_relaxed_3,
                           max_pool_v1_2::is_ignored_nchw_relaxed_3,
                           max_pool_v1_2::get_examples_nchw_relaxed_3());
}

TEST_F(ValidationTest, max_pool_v1_2_nchw_relaxed_3) {
  const Model model = max_pool_v1_2::createTestModel_nchw_relaxed_3();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nchw_relaxed_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nchw_quant8_3) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nchw_quant8_3,
                           max_pool_v1_2::is_ignored_nchw_quant8_3,
                           max_pool_v1_2::get_examples_nchw_quant8_3());
}

TEST_F(ValidationTest, max_pool_v1_2_nchw_quant8_3) {
  const Model model = max_pool_v1_2::createTestModel_nchw_quant8_3();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nchw_quant8_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nhwc_4) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nhwc_4,
                           max_pool_v1_2::is_ignored_nhwc_4,
                           max_pool_v1_2::get_examples_nhwc_4());
}

TEST_F(ValidationTest, max_pool_v1_2_nhwc_4) {
  const Model model = max_pool_v1_2::createTestModel_nhwc_4();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nhwc_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nhwc_relaxed_4) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nhwc_relaxed_4,
                           max_pool_v1_2::is_ignored_nhwc_relaxed_4,
                           max_pool_v1_2::get_examples_nhwc_relaxed_4());
}

TEST_F(ValidationTest, max_pool_v1_2_nhwc_relaxed_4) {
  const Model model = max_pool_v1_2::createTestModel_nhwc_relaxed_4();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nhwc_relaxed_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nhwc_quant8_4) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nhwc_quant8_4,
                           max_pool_v1_2::is_ignored_nhwc_quant8_4,
                           max_pool_v1_2::get_examples_nhwc_quant8_4());
}

TEST_F(ValidationTest, max_pool_v1_2_nhwc_quant8_4) {
  const Model model = max_pool_v1_2::createTestModel_nhwc_quant8_4();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nhwc_quant8_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nchw_4) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nchw_4,
                           max_pool_v1_2::is_ignored_nchw_4,
                           max_pool_v1_2::get_examples_nchw_4());
}

TEST_F(ValidationTest, max_pool_v1_2_nchw_4) {
  const Model model = max_pool_v1_2::createTestModel_nchw_4();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nchw_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nchw_relaxed_4) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nchw_relaxed_4,
                           max_pool_v1_2::is_ignored_nchw_relaxed_4,
                           max_pool_v1_2::get_examples_nchw_relaxed_4());
}

TEST_F(ValidationTest, max_pool_v1_2_nchw_relaxed_4) {
  const Model model = max_pool_v1_2::createTestModel_nchw_relaxed_4();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nchw_relaxed_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, max_pool_v1_2_nchw_quant8_4) {
  generated_tests::Execute(device,
                           max_pool_v1_2::createTestModel_nchw_quant8_4,
                           max_pool_v1_2::is_ignored_nchw_quant8_4,
                           max_pool_v1_2::get_examples_nchw_quant8_4());
}

TEST_F(ValidationTest, max_pool_v1_2_nchw_quant8_4) {
  const Model model = max_pool_v1_2::createTestModel_nchw_quant8_4();
  const std::vector<Request> requests = createRequests(max_pool_v1_2::get_examples_nchw_quant8_4());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: maximum.mod.py.
namespace maximum {
// Generated maximum test
#include "examples/maximum.example.cpp"
// Generated model constructor
#include "vts_models/maximum.model.cpp"
} // namespace maximum

TEST_F(NeuralnetworksHidlTest, maximum_simple) {
  generated_tests::Execute(device,
                           maximum::createTestModel,
                           maximum::is_ignored,
                           maximum::get_examples_simple());
}

TEST_F(ValidationTest, maximum_simple) {
  const Model model = maximum::createTestModel();
  const std::vector<Request> requests = createRequests(maximum::get_examples_simple());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, maximum_simple_relaxed) {
  generated_tests::Execute(device,
                           maximum::createTestModel_relaxed,
                           maximum::is_ignored_relaxed,
                           maximum::get_examples_simple_relaxed());
}

TEST_F(ValidationTest, maximum_simple_relaxed) {
  const Model model = maximum::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(maximum::get_examples_simple_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, maximum_simple_quant8) {
  generated_tests::Execute(device,
                           maximum::createTestModel_quant8,
                           maximum::is_ignored_quant8,
                           maximum::get_examples_simple_quant8());
}

TEST_F(ValidationTest, maximum_simple_quant8) {
  const Model model = maximum::createTestModel_quant8();
  const std::vector<Request> requests = createRequests(maximum::get_examples_simple_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, maximum_simple_int32) {
  generated_tests::Execute(device,
                           maximum::createTestModel_int32,
                           maximum::is_ignored_int32,
                           maximum::get_examples_simple_int32());
}

TEST_F(ValidationTest, maximum_simple_int32) {
  const Model model = maximum::createTestModel_int32();
  const std::vector<Request> requests = createRequests(maximum::get_examples_simple_int32());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, maximum_simple_float16) {
  generated_tests::Execute(device,
                           maximum::createTestModel_float16,
                           maximum::is_ignored_float16,
                           maximum::get_examples_simple_float16());
}

TEST_F(ValidationTest, maximum_simple_float16) {
  const Model model = maximum::createTestModel_float16();
  const std::vector<Request> requests = createRequests(maximum::get_examples_simple_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, maximum_broadcast) {
  generated_tests::Execute(device,
                           maximum::createTestModel_2,
                           maximum::is_ignored_2,
                           maximum::get_examples_broadcast());
}

TEST_F(ValidationTest, maximum_broadcast) {
  const Model model = maximum::createTestModel_2();
  const std::vector<Request> requests = createRequests(maximum::get_examples_broadcast());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, maximum_broadcast_relaxed) {
  generated_tests::Execute(device,
                           maximum::createTestModel_relaxed_2,
                           maximum::is_ignored_relaxed_2,
                           maximum::get_examples_broadcast_relaxed());
}

TEST_F(ValidationTest, maximum_broadcast_relaxed) {
  const Model model = maximum::createTestModel_relaxed_2();
  const std::vector<Request> requests = createRequests(maximum::get_examples_broadcast_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, maximum_broadcast_quant8) {
  generated_tests::Execute(device,
                           maximum::createTestModel_quant8_2,
                           maximum::is_ignored_quant8_2,
                           maximum::get_examples_broadcast_quant8());
}

TEST_F(ValidationTest, maximum_broadcast_quant8) {
  const Model model = maximum::createTestModel_quant8_2();
  const std::vector<Request> requests = createRequests(maximum::get_examples_broadcast_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, maximum_broadcast_int32) {
  generated_tests::Execute(device,
                           maximum::createTestModel_int32_2,
                           maximum::is_ignored_int32_2,
                           maximum::get_examples_broadcast_int32());
}

TEST_F(ValidationTest, maximum_broadcast_int32) {
  const Model model = maximum::createTestModel_int32_2();
  const std::vector<Request> requests = createRequests(maximum::get_examples_broadcast_int32());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, maximum_broadcast_float16) {
  generated_tests::Execute(device,
                           maximum::createTestModel_float16_2,
                           maximum::is_ignored_float16_2,
                           maximum::get_examples_broadcast_float16());
}

TEST_F(ValidationTest, maximum_broadcast_float16) {
  const Model model = maximum::createTestModel_float16_2();
  const std::vector<Request> requests = createRequests(maximum::get_examples_broadcast_float16());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: minimum.mod.py.
namespace minimum {
// Generated minimum test
#include "examples/minimum.example.cpp"
// Generated model constructor
#include "vts_models/minimum.model.cpp"
} // namespace minimum

TEST_F(NeuralnetworksHidlTest, minimum_simple) {
  generated_tests::Execute(device,
                           minimum::createTestModel,
                           minimum::is_ignored,
                           minimum::get_examples_simple());
}

TEST_F(ValidationTest, minimum_simple) {
  const Model model = minimum::createTestModel();
  const std::vector<Request> requests = createRequests(minimum::get_examples_simple());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, minimum_simple_relaxed) {
  generated_tests::Execute(device,
                           minimum::createTestModel_relaxed,
                           minimum::is_ignored_relaxed,
                           minimum::get_examples_simple_relaxed());
}

TEST_F(ValidationTest, minimum_simple_relaxed) {
  const Model model = minimum::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(minimum::get_examples_simple_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, minimum_simple_quant8) {
  generated_tests::Execute(device,
                           minimum::createTestModel_quant8,
                           minimum::is_ignored_quant8,
                           minimum::get_examples_simple_quant8());
}

TEST_F(ValidationTest, minimum_simple_quant8) {
  const Model model = minimum::createTestModel_quant8();
  const std::vector<Request> requests = createRequests(minimum::get_examples_simple_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, minimum_simple_int32) {
  generated_tests::Execute(device,
                           minimum::createTestModel_int32,
                           minimum::is_ignored_int32,
                           minimum::get_examples_simple_int32());
}

TEST_F(ValidationTest, minimum_simple_int32) {
  const Model model = minimum::createTestModel_int32();
  const std::vector<Request> requests = createRequests(minimum::get_examples_simple_int32());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, minimum_simple_float16) {
  generated_tests::Execute(device,
                           minimum::createTestModel_float16,
                           minimum::is_ignored_float16,
                           minimum::get_examples_simple_float16());
}

TEST_F(ValidationTest, minimum_simple_float16) {
  const Model model = minimum::createTestModel_float16();
  const std::vector<Request> requests = createRequests(minimum::get_examples_simple_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, minimum_broadcast) {
  generated_tests::Execute(device,
                           minimum::createTestModel_2,
                           minimum::is_ignored_2,
                           minimum::get_examples_broadcast());
}

TEST_F(ValidationTest, minimum_broadcast) {
  const Model model = minimum::createTestModel_2();
  const std::vector<Request> requests = createRequests(minimum::get_examples_broadcast());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, minimum_broadcast_relaxed) {
  generated_tests::Execute(device,
                           minimum::createTestModel_relaxed_2,
                           minimum::is_ignored_relaxed_2,
                           minimum::get_examples_broadcast_relaxed());
}

TEST_F(ValidationTest, minimum_broadcast_relaxed) {
  const Model model = minimum::createTestModel_relaxed_2();
  const std::vector<Request> requests = createRequests(minimum::get_examples_broadcast_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, minimum_broadcast_quant8) {
  generated_tests::Execute(device,
                           minimum::createTestModel_quant8_2,
                           minimum::is_ignored_quant8_2,
                           minimum::get_examples_broadcast_quant8());
}

TEST_F(ValidationTest, minimum_broadcast_quant8) {
  const Model model = minimum::createTestModel_quant8_2();
  const std::vector<Request> requests = createRequests(minimum::get_examples_broadcast_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, minimum_broadcast_int32) {
  generated_tests::Execute(device,
                           minimum::createTestModel_int32_2,
                           minimum::is_ignored_int32_2,
                           minimum::get_examples_broadcast_int32());
}

TEST_F(ValidationTest, minimum_broadcast_int32) {
  const Model model = minimum::createTestModel_int32_2();
  const std::vector<Request> requests = createRequests(minimum::get_examples_broadcast_int32());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, minimum_broadcast_float16) {
  generated_tests::Execute(device,
                           minimum::createTestModel_float16_2,
                           minimum::is_ignored_float16_2,
                           minimum::get_examples_broadcast_float16());
}

TEST_F(ValidationTest, minimum_broadcast_float16) {
  const Model model = minimum::createTestModel_float16_2();
  const std::vector<Request> requests = createRequests(minimum::get_examples_broadcast_float16());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: mul_broadcast_float16.mod.py.
namespace mul_broadcast_float16 {
// Generated mul_broadcast_float16 test
#include "examples/mul_broadcast_float16.example.cpp"
// Generated model constructor
#include "vts_models/mul_broadcast_float16.model.cpp"
} // namespace mul_broadcast_float16

TEST_F(NeuralnetworksHidlTest, mul_broadcast_float16) {
  generated_tests::Execute(device,
                           mul_broadcast_float16::createTestModel,
                           mul_broadcast_float16::is_ignored,
                           mul_broadcast_float16::get_examples());
}

TEST_F(ValidationTest, mul_broadcast_float16) {
  const Model model = mul_broadcast_float16::createTestModel();
  const std::vector<Request> requests = createRequests(mul_broadcast_float16::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: mul_float16.mod.py.
namespace mul_float16 {
// Generated mul_float16 test
#include "examples/mul_float16.example.cpp"
// Generated model constructor
#include "vts_models/mul_float16.model.cpp"
} // namespace mul_float16

TEST_F(NeuralnetworksHidlTest, mul_float16) {
  generated_tests::Execute(device,
                           mul_float16::createTestModel,
                           mul_float16::is_ignored,
                           mul_float16::get_examples());
}

TEST_F(ValidationTest, mul_float16) {
  const Model model = mul_float16::createTestModel();
  const std::vector<Request> requests = createRequests(mul_float16::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: pad_float16.mod.py.
namespace pad_float16 {
// Generated pad_float16 test
#include "examples/pad_float16.example.cpp"
// Generated model constructor
#include "vts_models/pad_float16.model.cpp"
} // namespace pad_float16

TEST_F(NeuralnetworksHidlTest, pad_float16) {
  generated_tests::Execute(device,
                           pad_float16::createTestModel,
                           pad_float16::is_ignored,
                           pad_float16::get_examples());
}

TEST_F(ValidationTest, pad_float16) {
  const Model model = pad_float16::createTestModel();
  const std::vector<Request> requests = createRequests(pad_float16::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: pad_v2_1_float.mod.py.
namespace pad_v2_1_float {
// Generated pad_v2_1_float test
#include "examples/pad_v2_1_float.example.cpp"
// Generated model constructor
#include "vts_models/pad_v2_1_float.model.cpp"
} // namespace pad_v2_1_float

TEST_F(NeuralnetworksHidlTest, pad_v2_1_float) {
  generated_tests::Execute(device,
                           pad_v2_1_float::createTestModel,
                           pad_v2_1_float::is_ignored,
                           pad_v2_1_float::get_examples());
}

TEST_F(ValidationTest, pad_v2_1_float) {
  const Model model = pad_v2_1_float::createTestModel();
  const std::vector<Request> requests = createRequests(pad_v2_1_float::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, pad_v2_1_float_float16) {
  generated_tests::Execute(device,
                           pad_v2_1_float::createTestModel_float16,
                           pad_v2_1_float::is_ignored_float16,
                           pad_v2_1_float::get_examples_float16());
}

TEST_F(ValidationTest, pad_v2_1_float_float16) {
  const Model model = pad_v2_1_float::createTestModel_float16();
  const std::vector<Request> requests = createRequests(pad_v2_1_float::get_examples_float16());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: pad_v2_1_float_relaxed.mod.py.
namespace pad_v2_1_float_relaxed {
// Generated pad_v2_1_float_relaxed test
#include "examples/pad_v2_1_float_relaxed.example.cpp"
// Generated model constructor
#include "vts_models/pad_v2_1_float_relaxed.model.cpp"
} // namespace pad_v2_1_float_relaxed

TEST_F(NeuralnetworksHidlTest, pad_v2_1_float_relaxed) {
  generated_tests::Execute(device,
                           pad_v2_1_float_relaxed::createTestModel,
                           pad_v2_1_float_relaxed::is_ignored,
                           pad_v2_1_float_relaxed::get_examples());
}

TEST_F(ValidationTest, pad_v2_1_float_relaxed) {
  const Model model = pad_v2_1_float_relaxed::createTestModel();
  const std::vector<Request> requests = createRequests(pad_v2_1_float_relaxed::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: pad_v2_1_quant8.mod.py.
namespace pad_v2_1_quant8 {
// Generated pad_v2_1_quant8 test
#include "examples/pad_v2_1_quant8.example.cpp"
// Generated model constructor
#include "vts_models/pad_v2_1_quant8.model.cpp"
} // namespace pad_v2_1_quant8

TEST_F(NeuralnetworksHidlTest, pad_v2_1_quant8) {
  generated_tests::Execute(device,
                           pad_v2_1_quant8::createTestModel,
                           pad_v2_1_quant8::is_ignored,
                           pad_v2_1_quant8::get_examples());
}

TEST_F(ValidationTest, pad_v2_1_quant8) {
  const Model model = pad_v2_1_quant8::createTestModel();
  const std::vector<Request> requests = createRequests(pad_v2_1_quant8::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: pow.mod.py.
namespace pow {
// Generated pow test
#include "examples/pow.example.cpp"
// Generated model constructor
#include "vts_models/pow.model.cpp"
} // namespace pow

TEST_F(NeuralnetworksHidlTest, pow) {
  generated_tests::Execute(device,
                           pow::createTestModel,
                           pow::is_ignored,
                           pow::get_examples());
}

TEST_F(ValidationTest, pow) {
  const Model model = pow::createTestModel();
  const std::vector<Request> requests = createRequests(pow::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, pow_relaxed) {
  generated_tests::Execute(device,
                           pow::createTestModel_relaxed,
                           pow::is_ignored_relaxed,
                           pow::get_examples_relaxed());
}

TEST_F(ValidationTest, pow_relaxed) {
  const Model model = pow::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(pow::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, pow_2) {
  generated_tests::Execute(device,
                           pow::createTestModel_2,
                           pow::is_ignored_2,
                           pow::get_examples_2());
}

TEST_F(ValidationTest, pow_2) {
  const Model model = pow::createTestModel_2();
  const std::vector<Request> requests = createRequests(pow::get_examples_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, pow_relaxed_2) {
  generated_tests::Execute(device,
                           pow::createTestModel_relaxed_2,
                           pow::is_ignored_relaxed_2,
                           pow::get_examples_relaxed_2());
}

TEST_F(ValidationTest, pow_relaxed_2) {
  const Model model = pow::createTestModel_relaxed_2();
  const std::vector<Request> requests = createRequests(pow::get_examples_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, pow_3) {
  generated_tests::Execute(device,
                           pow::createTestModel_3,
                           pow::is_ignored_3,
                           pow::get_examples_3());
}

TEST_F(ValidationTest, pow_3) {
  const Model model = pow::createTestModel_3();
  const std::vector<Request> requests = createRequests(pow::get_examples_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, pow_relaxed_3) {
  generated_tests::Execute(device,
                           pow::createTestModel_relaxed_3,
                           pow::is_ignored_relaxed_3,
                           pow::get_examples_relaxed_3());
}

TEST_F(ValidationTest, pow_relaxed_3) {
  const Model model = pow::createTestModel_relaxed_3();
  const std::vector<Request> requests = createRequests(pow::get_examples_relaxed_3());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: prelu.mod.py.
namespace prelu {
// Generated prelu test
#include "examples/prelu.example.cpp"
// Generated model constructor
#include "vts_models/prelu.model.cpp"
} // namespace prelu

TEST_F(NeuralnetworksHidlTest, prelu) {
  generated_tests::Execute(device,
                           prelu::createTestModel,
                           prelu::is_ignored,
                           prelu::get_examples());
}

TEST_F(ValidationTest, prelu) {
  const Model model = prelu::createTestModel();
  const std::vector<Request> requests = createRequests(prelu::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, prelu_relaxed) {
  generated_tests::Execute(device,
                           prelu::createTestModel_relaxed,
                           prelu::is_ignored_relaxed,
                           prelu::get_examples_relaxed());
}

TEST_F(ValidationTest, prelu_relaxed) {
  const Model model = prelu::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(prelu::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, prelu_quant8) {
  generated_tests::Execute(device,
                           prelu::createTestModel_quant8,
                           prelu::is_ignored_quant8,
                           prelu::get_examples_quant8());
}

TEST_F(ValidationTest, prelu_quant8) {
  const Model model = prelu::createTestModel_quant8();
  const std::vector<Request> requests = createRequests(prelu::get_examples_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, prelu_weight_as_input) {
  generated_tests::Execute(device,
                           prelu::createTestModel_weight_as_input,
                           prelu::is_ignored_weight_as_input,
                           prelu::get_examples_weight_as_input());
}

TEST_F(ValidationTest, prelu_weight_as_input) {
  const Model model = prelu::createTestModel_weight_as_input();
  const std::vector<Request> requests = createRequests(prelu::get_examples_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, prelu_weight_as_input_relaxed) {
  generated_tests::Execute(device,
                           prelu::createTestModel_weight_as_input_relaxed,
                           prelu::is_ignored_weight_as_input_relaxed,
                           prelu::get_examples_weight_as_input_relaxed());
}

TEST_F(ValidationTest, prelu_weight_as_input_relaxed) {
  const Model model = prelu::createTestModel_weight_as_input_relaxed();
  const std::vector<Request> requests = createRequests(prelu::get_examples_weight_as_input_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, prelu_weight_as_input_quant8) {
  generated_tests::Execute(device,
                           prelu::createTestModel_weight_as_input_quant8,
                           prelu::is_ignored_weight_as_input_quant8,
                           prelu::get_examples_weight_as_input_quant8());
}

TEST_F(ValidationTest, prelu_weight_as_input_quant8) {
  const Model model = prelu::createTestModel_weight_as_input_quant8();
  const std::vector<Request> requests = createRequests(prelu::get_examples_weight_as_input_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: quantize.mod.py.
namespace quantize {
// Generated quantize test
#include "examples/quantize.example.cpp"
// Generated model constructor
#include "vts_models/quantize.model.cpp"
} // namespace quantize

TEST_F(NeuralnetworksHidlTest, quantize_quant8) {
  generated_tests::Execute(device,
                           quantize::createTestModel_quant8,
                           quantize::is_ignored_quant8,
                           quantize::get_examples_quant8());
}

TEST_F(ValidationTest, quantize_quant8) {
  const Model model = quantize::createTestModel_quant8();
  const std::vector<Request> requests = createRequests(quantize::get_examples_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, quantize_quant8_2) {
  generated_tests::Execute(device,
                           quantize::createTestModel_quant8_2,
                           quantize::is_ignored_quant8_2,
                           quantize::get_examples_quant8_2());
}

TEST_F(ValidationTest, quantize_quant8_2) {
  const Model model = quantize::createTestModel_quant8_2();
  const std::vector<Request> requests = createRequests(quantize::get_examples_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, quantize_quant8_3) {
  generated_tests::Execute(device,
                           quantize::createTestModel_quant8_3,
                           quantize::is_ignored_quant8_3,
                           quantize::get_examples_quant8_3());
}

TEST_F(ValidationTest, quantize_quant8_3) {
  const Model model = quantize::createTestModel_quant8_3();
  const std::vector<Request> requests = createRequests(quantize::get_examples_quant8_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, quantize_quant8_4) {
  generated_tests::Execute(device,
                           quantize::createTestModel_quant8_4,
                           quantize::is_ignored_quant8_4,
                           quantize::get_examples_quant8_4());
}

TEST_F(ValidationTest, quantize_quant8_4) {
  const Model model = quantize::createTestModel_quant8_4();
  const std::vector<Request> requests = createRequests(quantize::get_examples_quant8_4());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: quantized_lstm.mod.py.
namespace quantized_lstm {
// Generated quantized_lstm test
#include "examples/quantized_lstm.example.cpp"
// Generated model constructor
#include "vts_models/quantized_lstm.model.cpp"
} // namespace quantized_lstm

TEST_F(NeuralnetworksHidlTest, quantized_lstm) {
  generated_tests::Execute(device,
                           quantized_lstm::createTestModel,
                           quantized_lstm::is_ignored,
                           quantized_lstm::get_examples());
}

TEST_F(ValidationTest, quantized_lstm) {
  const Model model = quantized_lstm::createTestModel();
  const std::vector<Request> requests = createRequests(quantized_lstm::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: random_multinomial.mod.py.
namespace random_multinomial {
// Generated random_multinomial test
#include "examples/random_multinomial.example.cpp"
// Generated model constructor
#include "vts_models/random_multinomial.model.cpp"
} // namespace random_multinomial

TEST_F(NeuralnetworksHidlTest, random_multinomial) {
  generated_tests::Execute(device,
                           random_multinomial::createTestModel,
                           random_multinomial::is_ignored,
                           random_multinomial::get_examples());
}

TEST_F(ValidationTest, random_multinomial) {
  const Model model = random_multinomial::createTestModel();
  const std::vector<Request> requests = createRequests(random_multinomial::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: relu1_float16_1.mod.py.
namespace relu1_float16_1 {
// Generated relu1_float16_1 test
#include "examples/relu1_float16_1.example.cpp"
// Generated model constructor
#include "vts_models/relu1_float16_1.model.cpp"
} // namespace relu1_float16_1

TEST_F(NeuralnetworksHidlTest, relu1_float16_1) {
  generated_tests::Execute(device,
                           relu1_float16_1::createTestModel,
                           relu1_float16_1::is_ignored,
                           relu1_float16_1::get_examples());
}

TEST_F(ValidationTest, relu1_float16_1) {
  const Model model = relu1_float16_1::createTestModel();
  const std::vector<Request> requests = createRequests(relu1_float16_1::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: relu1_float16_2.mod.py.
namespace relu1_float16_2 {
// Generated relu1_float16_2 test
#include "examples/relu1_float16_2.example.cpp"
// Generated model constructor
#include "vts_models/relu1_float16_2.model.cpp"
} // namespace relu1_float16_2

TEST_F(NeuralnetworksHidlTest, relu1_float16_2) {
  generated_tests::Execute(device,
                           relu1_float16_2::createTestModel,
                           relu1_float16_2::is_ignored,
                           relu1_float16_2::get_examples());
}

TEST_F(ValidationTest, relu1_float16_2) {
  const Model model = relu1_float16_2::createTestModel();
  const std::vector<Request> requests = createRequests(relu1_float16_2::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: relu6_float16_1.mod.py.
namespace relu6_float16_1 {
// Generated relu6_float16_1 test
#include "examples/relu6_float16_1.example.cpp"
// Generated model constructor
#include "vts_models/relu6_float16_1.model.cpp"
} // namespace relu6_float16_1

TEST_F(NeuralnetworksHidlTest, relu6_float16_1) {
  generated_tests::Execute(device,
                           relu6_float16_1::createTestModel,
                           relu6_float16_1::is_ignored,
                           relu6_float16_1::get_examples());
}

TEST_F(ValidationTest, relu6_float16_1) {
  const Model model = relu6_float16_1::createTestModel();
  const std::vector<Request> requests = createRequests(relu6_float16_1::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: relu6_float16_2.mod.py.
namespace relu6_float16_2 {
// Generated relu6_float16_2 test
#include "examples/relu6_float16_2.example.cpp"
// Generated model constructor
#include "vts_models/relu6_float16_2.model.cpp"
} // namespace relu6_float16_2

TEST_F(NeuralnetworksHidlTest, relu6_float16_2) {
  generated_tests::Execute(device,
                           relu6_float16_2::createTestModel,
                           relu6_float16_2::is_ignored,
                           relu6_float16_2::get_examples());
}

TEST_F(ValidationTest, relu6_float16_2) {
  const Model model = relu6_float16_2::createTestModel();
  const std::vector<Request> requests = createRequests(relu6_float16_2::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: relu_float16_1.mod.py.
namespace relu_float16_1 {
// Generated relu_float16_1 test
#include "examples/relu_float16_1.example.cpp"
// Generated model constructor
#include "vts_models/relu_float16_1.model.cpp"
} // namespace relu_float16_1

TEST_F(NeuralnetworksHidlTest, relu_float16_1) {
  generated_tests::Execute(device,
                           relu_float16_1::createTestModel,
                           relu_float16_1::is_ignored,
                           relu_float16_1::get_examples());
}

TEST_F(ValidationTest, relu_float16_1) {
  const Model model = relu_float16_1::createTestModel();
  const std::vector<Request> requests = createRequests(relu_float16_1::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: relu_float16_2.mod.py.
namespace relu_float16_2 {
// Generated relu_float16_2 test
#include "examples/relu_float16_2.example.cpp"
// Generated model constructor
#include "vts_models/relu_float16_2.model.cpp"
} // namespace relu_float16_2

TEST_F(NeuralnetworksHidlTest, relu_float16_2) {
  generated_tests::Execute(device,
                           relu_float16_2::createTestModel,
                           relu_float16_2::is_ignored,
                           relu_float16_2::get_examples());
}

TEST_F(ValidationTest, relu_float16_2) {
  const Model model = relu_float16_2::createTestModel();
  const std::vector<Request> requests = createRequests(relu_float16_2::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: reshape_float16.mod.py.
namespace reshape_float16 {
// Generated reshape_float16 test
#include "examples/reshape_float16.example.cpp"
// Generated model constructor
#include "vts_models/reshape_float16.model.cpp"
} // namespace reshape_float16

TEST_F(NeuralnetworksHidlTest, reshape_float16) {
  generated_tests::Execute(device,
                           reshape_float16::createTestModel,
                           reshape_float16::is_ignored,
                           reshape_float16::get_examples());
}

TEST_F(ValidationTest, reshape_float16) {
  const Model model = reshape_float16::createTestModel();
  const std::vector<Request> requests = createRequests(reshape_float16::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: resize_bilinear_v1_2.mod.py.
namespace resize_bilinear_v1_2 {
// Generated resize_bilinear_v1_2 test
#include "examples/resize_bilinear_v1_2.example.cpp"
// Generated model constructor
#include "vts_models/resize_bilinear_v1_2.model.cpp"
} // namespace resize_bilinear_v1_2

TEST_F(NeuralnetworksHidlTest, resize_bilinear_v1_2_nhwc) {
  generated_tests::Execute(device,
                           resize_bilinear_v1_2::createTestModel_nhwc,
                           resize_bilinear_v1_2::is_ignored_nhwc,
                           resize_bilinear_v1_2::get_examples_nhwc());
}

TEST_F(ValidationTest, resize_bilinear_v1_2_nhwc) {
  const Model model = resize_bilinear_v1_2::createTestModel_nhwc();
  const std::vector<Request> requests = createRequests(resize_bilinear_v1_2::get_examples_nhwc());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, resize_bilinear_v1_2_nhwc_relaxed) {
  generated_tests::Execute(device,
                           resize_bilinear_v1_2::createTestModel_nhwc_relaxed,
                           resize_bilinear_v1_2::is_ignored_nhwc_relaxed,
                           resize_bilinear_v1_2::get_examples_nhwc_relaxed());
}

TEST_F(ValidationTest, resize_bilinear_v1_2_nhwc_relaxed) {
  const Model model = resize_bilinear_v1_2::createTestModel_nhwc_relaxed();
  const std::vector<Request> requests = createRequests(resize_bilinear_v1_2::get_examples_nhwc_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, resize_bilinear_v1_2_nhwc_float16) {
  generated_tests::Execute(device,
                           resize_bilinear_v1_2::createTestModel_nhwc_float16,
                           resize_bilinear_v1_2::is_ignored_nhwc_float16,
                           resize_bilinear_v1_2::get_examples_nhwc_float16());
}

TEST_F(ValidationTest, resize_bilinear_v1_2_nhwc_float16) {
  const Model model = resize_bilinear_v1_2::createTestModel_nhwc_float16();
  const std::vector<Request> requests = createRequests(resize_bilinear_v1_2::get_examples_nhwc_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, resize_bilinear_v1_2_nchw) {
  generated_tests::Execute(device,
                           resize_bilinear_v1_2::createTestModel_nchw,
                           resize_bilinear_v1_2::is_ignored_nchw,
                           resize_bilinear_v1_2::get_examples_nchw());
}

TEST_F(ValidationTest, resize_bilinear_v1_2_nchw) {
  const Model model = resize_bilinear_v1_2::createTestModel_nchw();
  const std::vector<Request> requests = createRequests(resize_bilinear_v1_2::get_examples_nchw());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, resize_bilinear_v1_2_nchw_relaxed) {
  generated_tests::Execute(device,
                           resize_bilinear_v1_2::createTestModel_nchw_relaxed,
                           resize_bilinear_v1_2::is_ignored_nchw_relaxed,
                           resize_bilinear_v1_2::get_examples_nchw_relaxed());
}

TEST_F(ValidationTest, resize_bilinear_v1_2_nchw_relaxed) {
  const Model model = resize_bilinear_v1_2::createTestModel_nchw_relaxed();
  const std::vector<Request> requests = createRequests(resize_bilinear_v1_2::get_examples_nchw_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, resize_bilinear_v1_2_nchw_float16) {
  generated_tests::Execute(device,
                           resize_bilinear_v1_2::createTestModel_nchw_float16,
                           resize_bilinear_v1_2::is_ignored_nchw_float16,
                           resize_bilinear_v1_2::get_examples_nchw_float16());
}

TEST_F(ValidationTest, resize_bilinear_v1_2_nchw_float16) {
  const Model model = resize_bilinear_v1_2::createTestModel_nchw_float16();
  const std::vector<Request> requests = createRequests(resize_bilinear_v1_2::get_examples_nchw_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, resize_bilinear_v1_2_nhwc_2) {
  generated_tests::Execute(device,
                           resize_bilinear_v1_2::createTestModel_nhwc_2,
                           resize_bilinear_v1_2::is_ignored_nhwc_2,
                           resize_bilinear_v1_2::get_examples_nhwc_2());
}

TEST_F(ValidationTest, resize_bilinear_v1_2_nhwc_2) {
  const Model model = resize_bilinear_v1_2::createTestModel_nhwc_2();
  const std::vector<Request> requests = createRequests(resize_bilinear_v1_2::get_examples_nhwc_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, resize_bilinear_v1_2_nhwc_relaxed_2) {
  generated_tests::Execute(device,
                           resize_bilinear_v1_2::createTestModel_nhwc_relaxed_2,
                           resize_bilinear_v1_2::is_ignored_nhwc_relaxed_2,
                           resize_bilinear_v1_2::get_examples_nhwc_relaxed_2());
}

TEST_F(ValidationTest, resize_bilinear_v1_2_nhwc_relaxed_2) {
  const Model model = resize_bilinear_v1_2::createTestModel_nhwc_relaxed_2();
  const std::vector<Request> requests = createRequests(resize_bilinear_v1_2::get_examples_nhwc_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, resize_bilinear_v1_2_nhwc_float16_2) {
  generated_tests::Execute(device,
                           resize_bilinear_v1_2::createTestModel_nhwc_float16_2,
                           resize_bilinear_v1_2::is_ignored_nhwc_float16_2,
                           resize_bilinear_v1_2::get_examples_nhwc_float16_2());
}

TEST_F(ValidationTest, resize_bilinear_v1_2_nhwc_float16_2) {
  const Model model = resize_bilinear_v1_2::createTestModel_nhwc_float16_2();
  const std::vector<Request> requests = createRequests(resize_bilinear_v1_2::get_examples_nhwc_float16_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, resize_bilinear_v1_2_nchw_2) {
  generated_tests::Execute(device,
                           resize_bilinear_v1_2::createTestModel_nchw_2,
                           resize_bilinear_v1_2::is_ignored_nchw_2,
                           resize_bilinear_v1_2::get_examples_nchw_2());
}

TEST_F(ValidationTest, resize_bilinear_v1_2_nchw_2) {
  const Model model = resize_bilinear_v1_2::createTestModel_nchw_2();
  const std::vector<Request> requests = createRequests(resize_bilinear_v1_2::get_examples_nchw_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, resize_bilinear_v1_2_nchw_relaxed_2) {
  generated_tests::Execute(device,
                           resize_bilinear_v1_2::createTestModel_nchw_relaxed_2,
                           resize_bilinear_v1_2::is_ignored_nchw_relaxed_2,
                           resize_bilinear_v1_2::get_examples_nchw_relaxed_2());
}

TEST_F(ValidationTest, resize_bilinear_v1_2_nchw_relaxed_2) {
  const Model model = resize_bilinear_v1_2::createTestModel_nchw_relaxed_2();
  const std::vector<Request> requests = createRequests(resize_bilinear_v1_2::get_examples_nchw_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, resize_bilinear_v1_2_nchw_float16_2) {
  generated_tests::Execute(device,
                           resize_bilinear_v1_2::createTestModel_nchw_float16_2,
                           resize_bilinear_v1_2::is_ignored_nchw_float16_2,
                           resize_bilinear_v1_2::get_examples_nchw_float16_2());
}

TEST_F(ValidationTest, resize_bilinear_v1_2_nchw_float16_2) {
  const Model model = resize_bilinear_v1_2::createTestModel_nchw_float16_2();
  const std::vector<Request> requests = createRequests(resize_bilinear_v1_2::get_examples_nchw_float16_2());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: roi_align.mod.py.
namespace roi_align {
// Generated roi_align test
#include "examples/roi_align.example.cpp"
// Generated model constructor
#include "vts_models/roi_align.model.cpp"
} // namespace roi_align

TEST_F(NeuralnetworksHidlTest, roi_align_nhwc) {
  generated_tests::Execute(device,
                           roi_align::createTestModel_nhwc,
                           roi_align::is_ignored_nhwc,
                           roi_align::get_examples_nhwc());
}

TEST_F(ValidationTest, roi_align_nhwc) {
  const Model model = roi_align::createTestModel_nhwc();
  const std::vector<Request> requests = createRequests(roi_align::get_examples_nhwc());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, roi_align_nhwc_relaxed) {
  generated_tests::Execute(device,
                           roi_align::createTestModel_nhwc_relaxed,
                           roi_align::is_ignored_nhwc_relaxed,
                           roi_align::get_examples_nhwc_relaxed());
}

TEST_F(ValidationTest, roi_align_nhwc_relaxed) {
  const Model model = roi_align::createTestModel_nhwc_relaxed();
  const std::vector<Request> requests = createRequests(roi_align::get_examples_nhwc_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, roi_align_nhwc_quant8) {
  generated_tests::Execute(device,
                           roi_align::createTestModel_nhwc_quant8,
                           roi_align::is_ignored_nhwc_quant8,
                           roi_align::get_examples_nhwc_quant8());
}

TEST_F(ValidationTest, roi_align_nhwc_quant8) {
  const Model model = roi_align::createTestModel_nhwc_quant8();
  const std::vector<Request> requests = createRequests(roi_align::get_examples_nhwc_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, roi_align_nchw) {
  generated_tests::Execute(device,
                           roi_align::createTestModel_nchw,
                           roi_align::is_ignored_nchw,
                           roi_align::get_examples_nchw());
}

TEST_F(ValidationTest, roi_align_nchw) {
  const Model model = roi_align::createTestModel_nchw();
  const std::vector<Request> requests = createRequests(roi_align::get_examples_nchw());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, roi_align_nchw_relaxed) {
  generated_tests::Execute(device,
                           roi_align::createTestModel_nchw_relaxed,
                           roi_align::is_ignored_nchw_relaxed,
                           roi_align::get_examples_nchw_relaxed());
}

TEST_F(ValidationTest, roi_align_nchw_relaxed) {
  const Model model = roi_align::createTestModel_nchw_relaxed();
  const std::vector<Request> requests = createRequests(roi_align::get_examples_nchw_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, roi_align_nchw_quant8) {
  generated_tests::Execute(device,
                           roi_align::createTestModel_nchw_quant8,
                           roi_align::is_ignored_nchw_quant8,
                           roi_align::get_examples_nchw_quant8());
}

TEST_F(ValidationTest, roi_align_nchw_quant8) {
  const Model model = roi_align::createTestModel_nchw_quant8();
  const std::vector<Request> requests = createRequests(roi_align::get_examples_nchw_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, roi_align_nhwc_2) {
  generated_tests::Execute(device,
                           roi_align::createTestModel_nhwc_2,
                           roi_align::is_ignored_nhwc_2,
                           roi_align::get_examples_nhwc_2());
}

TEST_F(ValidationTest, roi_align_nhwc_2) {
  const Model model = roi_align::createTestModel_nhwc_2();
  const std::vector<Request> requests = createRequests(roi_align::get_examples_nhwc_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, roi_align_nhwc_relaxed_2) {
  generated_tests::Execute(device,
                           roi_align::createTestModel_nhwc_relaxed_2,
                           roi_align::is_ignored_nhwc_relaxed_2,
                           roi_align::get_examples_nhwc_relaxed_2());
}

TEST_F(ValidationTest, roi_align_nhwc_relaxed_2) {
  const Model model = roi_align::createTestModel_nhwc_relaxed_2();
  const std::vector<Request> requests = createRequests(roi_align::get_examples_nhwc_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, roi_align_nhwc_quant8_2) {
  generated_tests::Execute(device,
                           roi_align::createTestModel_nhwc_quant8_2,
                           roi_align::is_ignored_nhwc_quant8_2,
                           roi_align::get_examples_nhwc_quant8_2());
}

TEST_F(ValidationTest, roi_align_nhwc_quant8_2) {
  const Model model = roi_align::createTestModel_nhwc_quant8_2();
  const std::vector<Request> requests = createRequests(roi_align::get_examples_nhwc_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, roi_align_nchw_2) {
  generated_tests::Execute(device,
                           roi_align::createTestModel_nchw_2,
                           roi_align::is_ignored_nchw_2,
                           roi_align::get_examples_nchw_2());
}

TEST_F(ValidationTest, roi_align_nchw_2) {
  const Model model = roi_align::createTestModel_nchw_2();
  const std::vector<Request> requests = createRequests(roi_align::get_examples_nchw_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, roi_align_nchw_relaxed_2) {
  generated_tests::Execute(device,
                           roi_align::createTestModel_nchw_relaxed_2,
                           roi_align::is_ignored_nchw_relaxed_2,
                           roi_align::get_examples_nchw_relaxed_2());
}

TEST_F(ValidationTest, roi_align_nchw_relaxed_2) {
  const Model model = roi_align::createTestModel_nchw_relaxed_2();
  const std::vector<Request> requests = createRequests(roi_align::get_examples_nchw_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, roi_align_nchw_quant8_2) {
  generated_tests::Execute(device,
                           roi_align::createTestModel_nchw_quant8_2,
                           roi_align::is_ignored_nchw_quant8_2,
                           roi_align::get_examples_nchw_quant8_2());
}

TEST_F(ValidationTest, roi_align_nchw_quant8_2) {
  const Model model = roi_align::createTestModel_nchw_quant8_2();
  const std::vector<Request> requests = createRequests(roi_align::get_examples_nchw_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, roi_align_nhwc_3) {
  generated_tests::Execute(device,
                           roi_align::createTestModel_nhwc_3,
                           roi_align::is_ignored_nhwc_3,
                           roi_align::get_examples_nhwc_3());
}

TEST_F(ValidationTest, roi_align_nhwc_3) {
  const Model model = roi_align::createTestModel_nhwc_3();
  const std::vector<Request> requests = createRequests(roi_align::get_examples_nhwc_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, roi_align_nhwc_relaxed_3) {
  generated_tests::Execute(device,
                           roi_align::createTestModel_nhwc_relaxed_3,
                           roi_align::is_ignored_nhwc_relaxed_3,
                           roi_align::get_examples_nhwc_relaxed_3());
}

TEST_F(ValidationTest, roi_align_nhwc_relaxed_3) {
  const Model model = roi_align::createTestModel_nhwc_relaxed_3();
  const std::vector<Request> requests = createRequests(roi_align::get_examples_nhwc_relaxed_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, roi_align_nhwc_quant8_3) {
  generated_tests::Execute(device,
                           roi_align::createTestModel_nhwc_quant8_3,
                           roi_align::is_ignored_nhwc_quant8_3,
                           roi_align::get_examples_nhwc_quant8_3());
}

TEST_F(ValidationTest, roi_align_nhwc_quant8_3) {
  const Model model = roi_align::createTestModel_nhwc_quant8_3();
  const std::vector<Request> requests = createRequests(roi_align::get_examples_nhwc_quant8_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, roi_align_nchw_3) {
  generated_tests::Execute(device,
                           roi_align::createTestModel_nchw_3,
                           roi_align::is_ignored_nchw_3,
                           roi_align::get_examples_nchw_3());
}

TEST_F(ValidationTest, roi_align_nchw_3) {
  const Model model = roi_align::createTestModel_nchw_3();
  const std::vector<Request> requests = createRequests(roi_align::get_examples_nchw_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, roi_align_nchw_relaxed_3) {
  generated_tests::Execute(device,
                           roi_align::createTestModel_nchw_relaxed_3,
                           roi_align::is_ignored_nchw_relaxed_3,
                           roi_align::get_examples_nchw_relaxed_3());
}

TEST_F(ValidationTest, roi_align_nchw_relaxed_3) {
  const Model model = roi_align::createTestModel_nchw_relaxed_3();
  const std::vector<Request> requests = createRequests(roi_align::get_examples_nchw_relaxed_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, roi_align_nchw_quant8_3) {
  generated_tests::Execute(device,
                           roi_align::createTestModel_nchw_quant8_3,
                           roi_align::is_ignored_nchw_quant8_3,
                           roi_align::get_examples_nchw_quant8_3());
}

TEST_F(ValidationTest, roi_align_nchw_quant8_3) {
  const Model model = roi_align::createTestModel_nchw_quant8_3();
  const std::vector<Request> requests = createRequests(roi_align::get_examples_nchw_quant8_3());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: rotated_bbox_transform.mod.py.
namespace rotated_bbox_transform {
// Generated rotated_bbox_transform test
#include "examples/rotated_bbox_transform.example.cpp"
// Generated model constructor
#include "vts_models/rotated_bbox_transform.model.cpp"
} // namespace rotated_bbox_transform

TEST_F(NeuralnetworksHidlTest, rotated_bbox_transform) {
  generated_tests::Execute(device,
                           rotated_bbox_transform::createTestModel,
                           rotated_bbox_transform::is_ignored,
                           rotated_bbox_transform::get_examples());
}

TEST_F(ValidationTest, rotated_bbox_transform) {
  const Model model = rotated_bbox_transform::createTestModel();
  const std::vector<Request> requests = createRequests(rotated_bbox_transform::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, rotated_bbox_transform_relaxed) {
  generated_tests::Execute(device,
                           rotated_bbox_transform::createTestModel_relaxed,
                           rotated_bbox_transform::is_ignored_relaxed,
                           rotated_bbox_transform::get_examples_relaxed());
}

TEST_F(ValidationTest, rotated_bbox_transform_relaxed) {
  const Model model = rotated_bbox_transform::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(rotated_bbox_transform::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, rotated_bbox_transform_2) {
  generated_tests::Execute(device,
                           rotated_bbox_transform::createTestModel_2,
                           rotated_bbox_transform::is_ignored_2,
                           rotated_bbox_transform::get_examples_2());
}

TEST_F(ValidationTest, rotated_bbox_transform_2) {
  const Model model = rotated_bbox_transform::createTestModel_2();
  const std::vector<Request> requests = createRequests(rotated_bbox_transform::get_examples_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, rotated_bbox_transform_relaxed_2) {
  generated_tests::Execute(device,
                           rotated_bbox_transform::createTestModel_relaxed_2,
                           rotated_bbox_transform::is_ignored_relaxed_2,
                           rotated_bbox_transform::get_examples_relaxed_2());
}

TEST_F(ValidationTest, rotated_bbox_transform_relaxed_2) {
  const Model model = rotated_bbox_transform::createTestModel_relaxed_2();
  const std::vector<Request> requests = createRequests(rotated_bbox_transform::get_examples_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, rotated_bbox_transform_3) {
  generated_tests::Execute(device,
                           rotated_bbox_transform::createTestModel_3,
                           rotated_bbox_transform::is_ignored_3,
                           rotated_bbox_transform::get_examples_3());
}

TEST_F(ValidationTest, rotated_bbox_transform_3) {
  const Model model = rotated_bbox_transform::createTestModel_3();
  const std::vector<Request> requests = createRequests(rotated_bbox_transform::get_examples_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, rotated_bbox_transform_relaxed_3) {
  generated_tests::Execute(device,
                           rotated_bbox_transform::createTestModel_relaxed_3,
                           rotated_bbox_transform::is_ignored_relaxed_3,
                           rotated_bbox_transform::get_examples_relaxed_3());
}

TEST_F(ValidationTest, rotated_bbox_transform_relaxed_3) {
  const Model model = rotated_bbox_transform::createTestModel_relaxed_3();
  const std::vector<Request> requests = createRequests(rotated_bbox_transform::get_examples_relaxed_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, rotated_bbox_transform_single_batch) {
  generated_tests::Execute(device,
                           rotated_bbox_transform::createTestModel_single_batch,
                           rotated_bbox_transform::is_ignored_single_batch,
                           rotated_bbox_transform::get_examples_single_batch());
}

TEST_F(ValidationTest, rotated_bbox_transform_single_batch) {
  const Model model = rotated_bbox_transform::createTestModel_single_batch();
  const std::vector<Request> requests = createRequests(rotated_bbox_transform::get_examples_single_batch());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, rotated_bbox_transform_single_batch_relaxed) {
  generated_tests::Execute(device,
                           rotated_bbox_transform::createTestModel_single_batch_relaxed,
                           rotated_bbox_transform::is_ignored_single_batch_relaxed,
                           rotated_bbox_transform::get_examples_single_batch_relaxed());
}

TEST_F(ValidationTest, rotated_bbox_transform_single_batch_relaxed) {
  const Model model = rotated_bbox_transform::createTestModel_single_batch_relaxed();
  const std::vector<Request> requests = createRequests(rotated_bbox_transform::get_examples_single_batch_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: softmax_v1_2.mod.py.
namespace softmax_v1_2 {
// Generated softmax_v1_2 test
#include "examples/softmax_v1_2.example.cpp"
// Generated model constructor
#include "vts_models/softmax_v1_2.model.cpp"
} // namespace softmax_v1_2

TEST_F(NeuralnetworksHidlTest, softmax_v1_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel,
                           softmax_v1_2::is_ignored,
                           softmax_v1_2::get_examples());
}

TEST_F(ValidationTest, softmax_v1_2) {
  const Model model = softmax_v1_2::createTestModel();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_dim1_axis0) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_dim1_axis0,
                           softmax_v1_2::is_ignored_dim1_axis0,
                           softmax_v1_2::get_examples_dim1_axis0());
}

TEST_F(ValidationTest, softmax_v1_2_dim1_axis0) {
  const Model model = softmax_v1_2::createTestModel_dim1_axis0();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_dim1_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_dim3_axis2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_dim3_axis2,
                           softmax_v1_2::is_ignored_dim3_axis2,
                           softmax_v1_2::get_examples_dim3_axis2());
}

TEST_F(ValidationTest, softmax_v1_2_dim3_axis2) {
  const Model model = softmax_v1_2::createTestModel_dim3_axis2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_dim3_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_relaxed) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_relaxed,
                           softmax_v1_2::is_ignored_relaxed,
                           softmax_v1_2::get_examples_relaxed());
}

TEST_F(ValidationTest, softmax_v1_2_relaxed) {
  const Model model = softmax_v1_2::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_relaxed_dim1_axis0) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_relaxed_dim1_axis0,
                           softmax_v1_2::is_ignored_relaxed_dim1_axis0,
                           softmax_v1_2::get_examples_relaxed_dim1_axis0());
}

TEST_F(ValidationTest, softmax_v1_2_relaxed_dim1_axis0) {
  const Model model = softmax_v1_2::createTestModel_relaxed_dim1_axis0();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_relaxed_dim1_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_relaxed_dim3_axis2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_relaxed_dim3_axis2,
                           softmax_v1_2::is_ignored_relaxed_dim3_axis2,
                           softmax_v1_2::get_examples_relaxed_dim3_axis2());
}

TEST_F(ValidationTest, softmax_v1_2_relaxed_dim3_axis2) {
  const Model model = softmax_v1_2::createTestModel_relaxed_dim3_axis2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_relaxed_dim3_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_float16) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_float16,
                           softmax_v1_2::is_ignored_float16,
                           softmax_v1_2::get_examples_float16());
}

TEST_F(ValidationTest, softmax_v1_2_float16) {
  const Model model = softmax_v1_2::createTestModel_float16();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_float16_dim1_axis0) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_float16_dim1_axis0,
                           softmax_v1_2::is_ignored_float16_dim1_axis0,
                           softmax_v1_2::get_examples_float16_dim1_axis0());
}

TEST_F(ValidationTest, softmax_v1_2_float16_dim1_axis0) {
  const Model model = softmax_v1_2::createTestModel_float16_dim1_axis0();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_float16_dim1_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_float16_dim3_axis2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_float16_dim3_axis2,
                           softmax_v1_2::is_ignored_float16_dim3_axis2,
                           softmax_v1_2::get_examples_float16_dim3_axis2());
}

TEST_F(ValidationTest, softmax_v1_2_float16_dim3_axis2) {
  const Model model = softmax_v1_2::createTestModel_float16_dim3_axis2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_float16_dim3_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_quant8) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_quant8,
                           softmax_v1_2::is_ignored_quant8,
                           softmax_v1_2::get_examples_quant8());
}

TEST_F(ValidationTest, softmax_v1_2_quant8) {
  const Model model = softmax_v1_2::createTestModel_quant8();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_quant8_dim1_axis0) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_quant8_dim1_axis0,
                           softmax_v1_2::is_ignored_quant8_dim1_axis0,
                           softmax_v1_2::get_examples_quant8_dim1_axis0());
}

TEST_F(ValidationTest, softmax_v1_2_quant8_dim1_axis0) {
  const Model model = softmax_v1_2::createTestModel_quant8_dim1_axis0();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_quant8_dim1_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_quant8_dim3_axis2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_quant8_dim3_axis2,
                           softmax_v1_2::is_ignored_quant8_dim3_axis2,
                           softmax_v1_2::get_examples_quant8_dim3_axis2());
}

TEST_F(ValidationTest, softmax_v1_2_quant8_dim3_axis2) {
  const Model model = softmax_v1_2::createTestModel_quant8_dim3_axis2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_quant8_dim3_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_2,
                           softmax_v1_2::is_ignored_2,
                           softmax_v1_2::get_examples_2());
}

TEST_F(ValidationTest, softmax_v1_2_2) {
  const Model model = softmax_v1_2::createTestModel_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_dim1_axis0_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_dim1_axis0_2,
                           softmax_v1_2::is_ignored_dim1_axis0_2,
                           softmax_v1_2::get_examples_dim1_axis0_2());
}

TEST_F(ValidationTest, softmax_v1_2_dim1_axis0_2) {
  const Model model = softmax_v1_2::createTestModel_dim1_axis0_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_dim1_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_dim3_axis2_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_dim3_axis2_2,
                           softmax_v1_2::is_ignored_dim3_axis2_2,
                           softmax_v1_2::get_examples_dim3_axis2_2());
}

TEST_F(ValidationTest, softmax_v1_2_dim3_axis2_2) {
  const Model model = softmax_v1_2::createTestModel_dim3_axis2_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_dim3_axis2_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_relaxed_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_relaxed_2,
                           softmax_v1_2::is_ignored_relaxed_2,
                           softmax_v1_2::get_examples_relaxed_2());
}

TEST_F(ValidationTest, softmax_v1_2_relaxed_2) {
  const Model model = softmax_v1_2::createTestModel_relaxed_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_relaxed_dim1_axis0_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_relaxed_dim1_axis0_2,
                           softmax_v1_2::is_ignored_relaxed_dim1_axis0_2,
                           softmax_v1_2::get_examples_relaxed_dim1_axis0_2());
}

TEST_F(ValidationTest, softmax_v1_2_relaxed_dim1_axis0_2) {
  const Model model = softmax_v1_2::createTestModel_relaxed_dim1_axis0_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_relaxed_dim1_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_relaxed_dim3_axis2_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_relaxed_dim3_axis2_2,
                           softmax_v1_2::is_ignored_relaxed_dim3_axis2_2,
                           softmax_v1_2::get_examples_relaxed_dim3_axis2_2());
}

TEST_F(ValidationTest, softmax_v1_2_relaxed_dim3_axis2_2) {
  const Model model = softmax_v1_2::createTestModel_relaxed_dim3_axis2_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_relaxed_dim3_axis2_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_float16_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_float16_2,
                           softmax_v1_2::is_ignored_float16_2,
                           softmax_v1_2::get_examples_float16_2());
}

TEST_F(ValidationTest, softmax_v1_2_float16_2) {
  const Model model = softmax_v1_2::createTestModel_float16_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_float16_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_float16_dim1_axis0_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_float16_dim1_axis0_2,
                           softmax_v1_2::is_ignored_float16_dim1_axis0_2,
                           softmax_v1_2::get_examples_float16_dim1_axis0_2());
}

TEST_F(ValidationTest, softmax_v1_2_float16_dim1_axis0_2) {
  const Model model = softmax_v1_2::createTestModel_float16_dim1_axis0_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_float16_dim1_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_float16_dim3_axis2_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_float16_dim3_axis2_2,
                           softmax_v1_2::is_ignored_float16_dim3_axis2_2,
                           softmax_v1_2::get_examples_float16_dim3_axis2_2());
}

TEST_F(ValidationTest, softmax_v1_2_float16_dim3_axis2_2) {
  const Model model = softmax_v1_2::createTestModel_float16_dim3_axis2_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_float16_dim3_axis2_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_quant8_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_quant8_2,
                           softmax_v1_2::is_ignored_quant8_2,
                           softmax_v1_2::get_examples_quant8_2());
}

TEST_F(ValidationTest, softmax_v1_2_quant8_2) {
  const Model model = softmax_v1_2::createTestModel_quant8_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_quant8_dim1_axis0_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_quant8_dim1_axis0_2,
                           softmax_v1_2::is_ignored_quant8_dim1_axis0_2,
                           softmax_v1_2::get_examples_quant8_dim1_axis0_2());
}

TEST_F(ValidationTest, softmax_v1_2_quant8_dim1_axis0_2) {
  const Model model = softmax_v1_2::createTestModel_quant8_dim1_axis0_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_quant8_dim1_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_quant8_dim3_axis2_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_quant8_dim3_axis2_2,
                           softmax_v1_2::is_ignored_quant8_dim3_axis2_2,
                           softmax_v1_2::get_examples_quant8_dim3_axis2_2());
}

TEST_F(ValidationTest, softmax_v1_2_quant8_dim3_axis2_2) {
  const Model model = softmax_v1_2::createTestModel_quant8_dim3_axis2_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_quant8_dim3_axis2_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim4_axis0) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim4_axis0,
                           softmax_v1_2::is_ignored_axis_dim4_axis0,
                           softmax_v1_2::get_examples_axis_dim4_axis0());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim4_axis0) {
  const Model model = softmax_v1_2::createTestModel_axis_dim4_axis0();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim4_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim4_axis0_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim4_axis0_neg,
                           softmax_v1_2::is_ignored_axis_dim4_axis0_neg,
                           softmax_v1_2::get_examples_axis_dim4_axis0_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim4_axis0_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_dim4_axis0_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim4_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim4_axis1) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim4_axis1,
                           softmax_v1_2::is_ignored_axis_dim4_axis1,
                           softmax_v1_2::get_examples_axis_dim4_axis1());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim4_axis1) {
  const Model model = softmax_v1_2::createTestModel_axis_dim4_axis1();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim4_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim4_axis1_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim4_axis1_neg,
                           softmax_v1_2::is_ignored_axis_dim4_axis1_neg,
                           softmax_v1_2::get_examples_axis_dim4_axis1_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim4_axis1_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_dim4_axis1_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim4_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim4_axis2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim4_axis2,
                           softmax_v1_2::is_ignored_axis_dim4_axis2,
                           softmax_v1_2::get_examples_axis_dim4_axis2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim4_axis2) {
  const Model model = softmax_v1_2::createTestModel_axis_dim4_axis2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim4_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim4_axis2_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim4_axis2_neg,
                           softmax_v1_2::is_ignored_axis_dim4_axis2_neg,
                           softmax_v1_2::get_examples_axis_dim4_axis2_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim4_axis2_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_dim4_axis2_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim4_axis2_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim4_axis3) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim4_axis3,
                           softmax_v1_2::is_ignored_axis_dim4_axis3,
                           softmax_v1_2::get_examples_axis_dim4_axis3());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim4_axis3) {
  const Model model = softmax_v1_2::createTestModel_axis_dim4_axis3();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim4_axis3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim4_axis3_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim4_axis3_neg,
                           softmax_v1_2::is_ignored_axis_dim4_axis3_neg,
                           softmax_v1_2::get_examples_axis_dim4_axis3_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim4_axis3_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_dim4_axis3_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim4_axis3_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim3_axis0) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim3_axis0,
                           softmax_v1_2::is_ignored_axis_dim3_axis0,
                           softmax_v1_2::get_examples_axis_dim3_axis0());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim3_axis0) {
  const Model model = softmax_v1_2::createTestModel_axis_dim3_axis0();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim3_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim3_axis0_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim3_axis0_neg,
                           softmax_v1_2::is_ignored_axis_dim3_axis0_neg,
                           softmax_v1_2::get_examples_axis_dim3_axis0_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim3_axis0_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_dim3_axis0_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim3_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim3_axis1) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim3_axis1,
                           softmax_v1_2::is_ignored_axis_dim3_axis1,
                           softmax_v1_2::get_examples_axis_dim3_axis1());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim3_axis1) {
  const Model model = softmax_v1_2::createTestModel_axis_dim3_axis1();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim3_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim3_axis1_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim3_axis1_neg,
                           softmax_v1_2::is_ignored_axis_dim3_axis1_neg,
                           softmax_v1_2::get_examples_axis_dim3_axis1_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim3_axis1_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_dim3_axis1_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim3_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim3_axis2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim3_axis2,
                           softmax_v1_2::is_ignored_axis_dim3_axis2,
                           softmax_v1_2::get_examples_axis_dim3_axis2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim3_axis2) {
  const Model model = softmax_v1_2::createTestModel_axis_dim3_axis2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim3_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim3_axis2_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim3_axis2_neg,
                           softmax_v1_2::is_ignored_axis_dim3_axis2_neg,
                           softmax_v1_2::get_examples_axis_dim3_axis2_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim3_axis2_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_dim3_axis2_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim3_axis2_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim2_axis0) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim2_axis0,
                           softmax_v1_2::is_ignored_axis_dim2_axis0,
                           softmax_v1_2::get_examples_axis_dim2_axis0());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim2_axis0) {
  const Model model = softmax_v1_2::createTestModel_axis_dim2_axis0();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim2_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim2_axis0_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim2_axis0_neg,
                           softmax_v1_2::is_ignored_axis_dim2_axis0_neg,
                           softmax_v1_2::get_examples_axis_dim2_axis0_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim2_axis0_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_dim2_axis0_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim2_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim2_axis1) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim2_axis1,
                           softmax_v1_2::is_ignored_axis_dim2_axis1,
                           softmax_v1_2::get_examples_axis_dim2_axis1());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim2_axis1) {
  const Model model = softmax_v1_2::createTestModel_axis_dim2_axis1();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim2_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim2_axis1_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim2_axis1_neg,
                           softmax_v1_2::is_ignored_axis_dim2_axis1_neg,
                           softmax_v1_2::get_examples_axis_dim2_axis1_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim2_axis1_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_dim2_axis1_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim2_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim1_axis0) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim1_axis0,
                           softmax_v1_2::is_ignored_axis_dim1_axis0,
                           softmax_v1_2::get_examples_axis_dim1_axis0());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim1_axis0) {
  const Model model = softmax_v1_2::createTestModel_axis_dim1_axis0();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim1_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim1_axis0_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim1_axis0_neg,
                           softmax_v1_2::is_ignored_axis_dim1_axis0_neg,
                           softmax_v1_2::get_examples_axis_dim1_axis0_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim1_axis0_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_dim1_axis0_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim1_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim4_axis0) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim4_axis0,
                           softmax_v1_2::is_ignored_axis_relaxed_dim4_axis0,
                           softmax_v1_2::get_examples_axis_relaxed_dim4_axis0());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim4_axis0) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim4_axis0();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim4_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim4_axis0_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim4_axis0_neg,
                           softmax_v1_2::is_ignored_axis_relaxed_dim4_axis0_neg,
                           softmax_v1_2::get_examples_axis_relaxed_dim4_axis0_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim4_axis0_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim4_axis0_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim4_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim4_axis1) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim4_axis1,
                           softmax_v1_2::is_ignored_axis_relaxed_dim4_axis1,
                           softmax_v1_2::get_examples_axis_relaxed_dim4_axis1());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim4_axis1) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim4_axis1();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim4_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim4_axis1_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim4_axis1_neg,
                           softmax_v1_2::is_ignored_axis_relaxed_dim4_axis1_neg,
                           softmax_v1_2::get_examples_axis_relaxed_dim4_axis1_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim4_axis1_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim4_axis1_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim4_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim4_axis2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim4_axis2,
                           softmax_v1_2::is_ignored_axis_relaxed_dim4_axis2,
                           softmax_v1_2::get_examples_axis_relaxed_dim4_axis2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim4_axis2) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim4_axis2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim4_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim4_axis2_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim4_axis2_neg,
                           softmax_v1_2::is_ignored_axis_relaxed_dim4_axis2_neg,
                           softmax_v1_2::get_examples_axis_relaxed_dim4_axis2_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim4_axis2_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim4_axis2_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim4_axis2_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim4_axis3) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim4_axis3,
                           softmax_v1_2::is_ignored_axis_relaxed_dim4_axis3,
                           softmax_v1_2::get_examples_axis_relaxed_dim4_axis3());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim4_axis3) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim4_axis3();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim4_axis3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim4_axis3_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim4_axis3_neg,
                           softmax_v1_2::is_ignored_axis_relaxed_dim4_axis3_neg,
                           softmax_v1_2::get_examples_axis_relaxed_dim4_axis3_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim4_axis3_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim4_axis3_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim4_axis3_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim3_axis0) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim3_axis0,
                           softmax_v1_2::is_ignored_axis_relaxed_dim3_axis0,
                           softmax_v1_2::get_examples_axis_relaxed_dim3_axis0());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim3_axis0) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim3_axis0();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim3_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim3_axis0_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim3_axis0_neg,
                           softmax_v1_2::is_ignored_axis_relaxed_dim3_axis0_neg,
                           softmax_v1_2::get_examples_axis_relaxed_dim3_axis0_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim3_axis0_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim3_axis0_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim3_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim3_axis1) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim3_axis1,
                           softmax_v1_2::is_ignored_axis_relaxed_dim3_axis1,
                           softmax_v1_2::get_examples_axis_relaxed_dim3_axis1());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim3_axis1) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim3_axis1();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim3_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim3_axis1_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim3_axis1_neg,
                           softmax_v1_2::is_ignored_axis_relaxed_dim3_axis1_neg,
                           softmax_v1_2::get_examples_axis_relaxed_dim3_axis1_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim3_axis1_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim3_axis1_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim3_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim3_axis2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim3_axis2,
                           softmax_v1_2::is_ignored_axis_relaxed_dim3_axis2,
                           softmax_v1_2::get_examples_axis_relaxed_dim3_axis2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim3_axis2) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim3_axis2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim3_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim3_axis2_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim3_axis2_neg,
                           softmax_v1_2::is_ignored_axis_relaxed_dim3_axis2_neg,
                           softmax_v1_2::get_examples_axis_relaxed_dim3_axis2_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim3_axis2_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim3_axis2_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim3_axis2_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim2_axis0) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim2_axis0,
                           softmax_v1_2::is_ignored_axis_relaxed_dim2_axis0,
                           softmax_v1_2::get_examples_axis_relaxed_dim2_axis0());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim2_axis0) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim2_axis0();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim2_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim2_axis0_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim2_axis0_neg,
                           softmax_v1_2::is_ignored_axis_relaxed_dim2_axis0_neg,
                           softmax_v1_2::get_examples_axis_relaxed_dim2_axis0_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim2_axis0_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim2_axis0_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim2_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim2_axis1) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim2_axis1,
                           softmax_v1_2::is_ignored_axis_relaxed_dim2_axis1,
                           softmax_v1_2::get_examples_axis_relaxed_dim2_axis1());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim2_axis1) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim2_axis1();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim2_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim2_axis1_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim2_axis1_neg,
                           softmax_v1_2::is_ignored_axis_relaxed_dim2_axis1_neg,
                           softmax_v1_2::get_examples_axis_relaxed_dim2_axis1_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim2_axis1_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim2_axis1_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim2_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim1_axis0) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim1_axis0,
                           softmax_v1_2::is_ignored_axis_relaxed_dim1_axis0,
                           softmax_v1_2::get_examples_axis_relaxed_dim1_axis0());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim1_axis0) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim1_axis0();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim1_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim1_axis0_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim1_axis0_neg,
                           softmax_v1_2::is_ignored_axis_relaxed_dim1_axis0_neg,
                           softmax_v1_2::get_examples_axis_relaxed_dim1_axis0_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim1_axis0_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim1_axis0_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim1_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim4_axis0) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim4_axis0,
                           softmax_v1_2::is_ignored_axis_float16_dim4_axis0,
                           softmax_v1_2::get_examples_axis_float16_dim4_axis0());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim4_axis0) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim4_axis0();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim4_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim4_axis0_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim4_axis0_neg,
                           softmax_v1_2::is_ignored_axis_float16_dim4_axis0_neg,
                           softmax_v1_2::get_examples_axis_float16_dim4_axis0_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim4_axis0_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim4_axis0_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim4_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim4_axis1) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim4_axis1,
                           softmax_v1_2::is_ignored_axis_float16_dim4_axis1,
                           softmax_v1_2::get_examples_axis_float16_dim4_axis1());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim4_axis1) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim4_axis1();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim4_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim4_axis1_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim4_axis1_neg,
                           softmax_v1_2::is_ignored_axis_float16_dim4_axis1_neg,
                           softmax_v1_2::get_examples_axis_float16_dim4_axis1_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim4_axis1_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim4_axis1_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim4_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim4_axis2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim4_axis2,
                           softmax_v1_2::is_ignored_axis_float16_dim4_axis2,
                           softmax_v1_2::get_examples_axis_float16_dim4_axis2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim4_axis2) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim4_axis2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim4_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim4_axis2_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim4_axis2_neg,
                           softmax_v1_2::is_ignored_axis_float16_dim4_axis2_neg,
                           softmax_v1_2::get_examples_axis_float16_dim4_axis2_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim4_axis2_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim4_axis2_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim4_axis2_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim4_axis3) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim4_axis3,
                           softmax_v1_2::is_ignored_axis_float16_dim4_axis3,
                           softmax_v1_2::get_examples_axis_float16_dim4_axis3());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim4_axis3) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim4_axis3();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim4_axis3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim4_axis3_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim4_axis3_neg,
                           softmax_v1_2::is_ignored_axis_float16_dim4_axis3_neg,
                           softmax_v1_2::get_examples_axis_float16_dim4_axis3_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim4_axis3_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim4_axis3_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim4_axis3_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim3_axis0) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim3_axis0,
                           softmax_v1_2::is_ignored_axis_float16_dim3_axis0,
                           softmax_v1_2::get_examples_axis_float16_dim3_axis0());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim3_axis0) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim3_axis0();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim3_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim3_axis0_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim3_axis0_neg,
                           softmax_v1_2::is_ignored_axis_float16_dim3_axis0_neg,
                           softmax_v1_2::get_examples_axis_float16_dim3_axis0_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim3_axis0_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim3_axis0_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim3_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim3_axis1) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim3_axis1,
                           softmax_v1_2::is_ignored_axis_float16_dim3_axis1,
                           softmax_v1_2::get_examples_axis_float16_dim3_axis1());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim3_axis1) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim3_axis1();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim3_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim3_axis1_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim3_axis1_neg,
                           softmax_v1_2::is_ignored_axis_float16_dim3_axis1_neg,
                           softmax_v1_2::get_examples_axis_float16_dim3_axis1_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim3_axis1_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim3_axis1_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim3_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim3_axis2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim3_axis2,
                           softmax_v1_2::is_ignored_axis_float16_dim3_axis2,
                           softmax_v1_2::get_examples_axis_float16_dim3_axis2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim3_axis2) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim3_axis2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim3_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim3_axis2_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim3_axis2_neg,
                           softmax_v1_2::is_ignored_axis_float16_dim3_axis2_neg,
                           softmax_v1_2::get_examples_axis_float16_dim3_axis2_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim3_axis2_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim3_axis2_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim3_axis2_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim2_axis0) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim2_axis0,
                           softmax_v1_2::is_ignored_axis_float16_dim2_axis0,
                           softmax_v1_2::get_examples_axis_float16_dim2_axis0());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim2_axis0) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim2_axis0();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim2_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim2_axis0_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim2_axis0_neg,
                           softmax_v1_2::is_ignored_axis_float16_dim2_axis0_neg,
                           softmax_v1_2::get_examples_axis_float16_dim2_axis0_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim2_axis0_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim2_axis0_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim2_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim2_axis1) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim2_axis1,
                           softmax_v1_2::is_ignored_axis_float16_dim2_axis1,
                           softmax_v1_2::get_examples_axis_float16_dim2_axis1());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim2_axis1) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim2_axis1();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim2_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim2_axis1_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim2_axis1_neg,
                           softmax_v1_2::is_ignored_axis_float16_dim2_axis1_neg,
                           softmax_v1_2::get_examples_axis_float16_dim2_axis1_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim2_axis1_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim2_axis1_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim2_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim1_axis0) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim1_axis0,
                           softmax_v1_2::is_ignored_axis_float16_dim1_axis0,
                           softmax_v1_2::get_examples_axis_float16_dim1_axis0());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim1_axis0) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim1_axis0();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim1_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim1_axis0_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim1_axis0_neg,
                           softmax_v1_2::is_ignored_axis_float16_dim1_axis0_neg,
                           softmax_v1_2::get_examples_axis_float16_dim1_axis0_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim1_axis0_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim1_axis0_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim1_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim4_axis0) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim4_axis0,
                           softmax_v1_2::is_ignored_axis_quant8_dim4_axis0,
                           softmax_v1_2::get_examples_axis_quant8_dim4_axis0());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim4_axis0) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim4_axis0();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim4_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim4_axis0_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim4_axis0_neg,
                           softmax_v1_2::is_ignored_axis_quant8_dim4_axis0_neg,
                           softmax_v1_2::get_examples_axis_quant8_dim4_axis0_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim4_axis0_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim4_axis0_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim4_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim4_axis1) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim4_axis1,
                           softmax_v1_2::is_ignored_axis_quant8_dim4_axis1,
                           softmax_v1_2::get_examples_axis_quant8_dim4_axis1());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim4_axis1) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim4_axis1();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim4_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim4_axis1_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim4_axis1_neg,
                           softmax_v1_2::is_ignored_axis_quant8_dim4_axis1_neg,
                           softmax_v1_2::get_examples_axis_quant8_dim4_axis1_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim4_axis1_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim4_axis1_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim4_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim4_axis2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim4_axis2,
                           softmax_v1_2::is_ignored_axis_quant8_dim4_axis2,
                           softmax_v1_2::get_examples_axis_quant8_dim4_axis2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim4_axis2) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim4_axis2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim4_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim4_axis2_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim4_axis2_neg,
                           softmax_v1_2::is_ignored_axis_quant8_dim4_axis2_neg,
                           softmax_v1_2::get_examples_axis_quant8_dim4_axis2_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim4_axis2_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim4_axis2_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim4_axis2_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim4_axis3) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim4_axis3,
                           softmax_v1_2::is_ignored_axis_quant8_dim4_axis3,
                           softmax_v1_2::get_examples_axis_quant8_dim4_axis3());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim4_axis3) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim4_axis3();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim4_axis3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim4_axis3_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim4_axis3_neg,
                           softmax_v1_2::is_ignored_axis_quant8_dim4_axis3_neg,
                           softmax_v1_2::get_examples_axis_quant8_dim4_axis3_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim4_axis3_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim4_axis3_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim4_axis3_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim3_axis0) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim3_axis0,
                           softmax_v1_2::is_ignored_axis_quant8_dim3_axis0,
                           softmax_v1_2::get_examples_axis_quant8_dim3_axis0());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim3_axis0) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim3_axis0();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim3_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim3_axis0_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim3_axis0_neg,
                           softmax_v1_2::is_ignored_axis_quant8_dim3_axis0_neg,
                           softmax_v1_2::get_examples_axis_quant8_dim3_axis0_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim3_axis0_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim3_axis0_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim3_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim3_axis1) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim3_axis1,
                           softmax_v1_2::is_ignored_axis_quant8_dim3_axis1,
                           softmax_v1_2::get_examples_axis_quant8_dim3_axis1());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim3_axis1) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim3_axis1();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim3_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim3_axis1_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim3_axis1_neg,
                           softmax_v1_2::is_ignored_axis_quant8_dim3_axis1_neg,
                           softmax_v1_2::get_examples_axis_quant8_dim3_axis1_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim3_axis1_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim3_axis1_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim3_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim3_axis2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim3_axis2,
                           softmax_v1_2::is_ignored_axis_quant8_dim3_axis2,
                           softmax_v1_2::get_examples_axis_quant8_dim3_axis2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim3_axis2) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim3_axis2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim3_axis2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim3_axis2_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim3_axis2_neg,
                           softmax_v1_2::is_ignored_axis_quant8_dim3_axis2_neg,
                           softmax_v1_2::get_examples_axis_quant8_dim3_axis2_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim3_axis2_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim3_axis2_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim3_axis2_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim2_axis0) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim2_axis0,
                           softmax_v1_2::is_ignored_axis_quant8_dim2_axis0,
                           softmax_v1_2::get_examples_axis_quant8_dim2_axis0());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim2_axis0) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim2_axis0();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim2_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim2_axis0_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim2_axis0_neg,
                           softmax_v1_2::is_ignored_axis_quant8_dim2_axis0_neg,
                           softmax_v1_2::get_examples_axis_quant8_dim2_axis0_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim2_axis0_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim2_axis0_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim2_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim2_axis1) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim2_axis1,
                           softmax_v1_2::is_ignored_axis_quant8_dim2_axis1,
                           softmax_v1_2::get_examples_axis_quant8_dim2_axis1());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim2_axis1) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim2_axis1();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim2_axis1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim2_axis1_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim2_axis1_neg,
                           softmax_v1_2::is_ignored_axis_quant8_dim2_axis1_neg,
                           softmax_v1_2::get_examples_axis_quant8_dim2_axis1_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim2_axis1_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim2_axis1_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim2_axis1_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim1_axis0) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim1_axis0,
                           softmax_v1_2::is_ignored_axis_quant8_dim1_axis0,
                           softmax_v1_2::get_examples_axis_quant8_dim1_axis0());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim1_axis0) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim1_axis0();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim1_axis0());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim1_axis0_neg) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim1_axis0_neg,
                           softmax_v1_2::is_ignored_axis_quant8_dim1_axis0_neg,
                           softmax_v1_2::get_examples_axis_quant8_dim1_axis0_neg());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim1_axis0_neg) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim1_axis0_neg();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim1_axis0_neg());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim4_axis0_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim4_axis0_2,
                           softmax_v1_2::is_ignored_axis_dim4_axis0_2,
                           softmax_v1_2::get_examples_axis_dim4_axis0_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim4_axis0_2) {
  const Model model = softmax_v1_2::createTestModel_axis_dim4_axis0_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim4_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim4_axis0_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim4_axis0_neg_2,
                           softmax_v1_2::is_ignored_axis_dim4_axis0_neg_2,
                           softmax_v1_2::get_examples_axis_dim4_axis0_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim4_axis0_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_dim4_axis0_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim4_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim4_axis1_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim4_axis1_2,
                           softmax_v1_2::is_ignored_axis_dim4_axis1_2,
                           softmax_v1_2::get_examples_axis_dim4_axis1_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim4_axis1_2) {
  const Model model = softmax_v1_2::createTestModel_axis_dim4_axis1_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim4_axis1_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim4_axis1_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim4_axis1_neg_2,
                           softmax_v1_2::is_ignored_axis_dim4_axis1_neg_2,
                           softmax_v1_2::get_examples_axis_dim4_axis1_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim4_axis1_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_dim4_axis1_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim4_axis1_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim4_axis2_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim4_axis2_2,
                           softmax_v1_2::is_ignored_axis_dim4_axis2_2,
                           softmax_v1_2::get_examples_axis_dim4_axis2_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim4_axis2_2) {
  const Model model = softmax_v1_2::createTestModel_axis_dim4_axis2_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim4_axis2_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim4_axis2_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim4_axis2_neg_2,
                           softmax_v1_2::is_ignored_axis_dim4_axis2_neg_2,
                           softmax_v1_2::get_examples_axis_dim4_axis2_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim4_axis2_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_dim4_axis2_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim4_axis2_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim4_axis3_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim4_axis3_2,
                           softmax_v1_2::is_ignored_axis_dim4_axis3_2,
                           softmax_v1_2::get_examples_axis_dim4_axis3_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim4_axis3_2) {
  const Model model = softmax_v1_2::createTestModel_axis_dim4_axis3_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim4_axis3_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim4_axis3_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim4_axis3_neg_2,
                           softmax_v1_2::is_ignored_axis_dim4_axis3_neg_2,
                           softmax_v1_2::get_examples_axis_dim4_axis3_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim4_axis3_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_dim4_axis3_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim4_axis3_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim3_axis0_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim3_axis0_2,
                           softmax_v1_2::is_ignored_axis_dim3_axis0_2,
                           softmax_v1_2::get_examples_axis_dim3_axis0_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim3_axis0_2) {
  const Model model = softmax_v1_2::createTestModel_axis_dim3_axis0_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim3_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim3_axis0_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim3_axis0_neg_2,
                           softmax_v1_2::is_ignored_axis_dim3_axis0_neg_2,
                           softmax_v1_2::get_examples_axis_dim3_axis0_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim3_axis0_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_dim3_axis0_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim3_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim3_axis1_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim3_axis1_2,
                           softmax_v1_2::is_ignored_axis_dim3_axis1_2,
                           softmax_v1_2::get_examples_axis_dim3_axis1_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim3_axis1_2) {
  const Model model = softmax_v1_2::createTestModel_axis_dim3_axis1_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim3_axis1_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim3_axis1_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim3_axis1_neg_2,
                           softmax_v1_2::is_ignored_axis_dim3_axis1_neg_2,
                           softmax_v1_2::get_examples_axis_dim3_axis1_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim3_axis1_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_dim3_axis1_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim3_axis1_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim3_axis2_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim3_axis2_2,
                           softmax_v1_2::is_ignored_axis_dim3_axis2_2,
                           softmax_v1_2::get_examples_axis_dim3_axis2_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim3_axis2_2) {
  const Model model = softmax_v1_2::createTestModel_axis_dim3_axis2_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim3_axis2_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim3_axis2_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim3_axis2_neg_2,
                           softmax_v1_2::is_ignored_axis_dim3_axis2_neg_2,
                           softmax_v1_2::get_examples_axis_dim3_axis2_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim3_axis2_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_dim3_axis2_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim3_axis2_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim2_axis0_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim2_axis0_2,
                           softmax_v1_2::is_ignored_axis_dim2_axis0_2,
                           softmax_v1_2::get_examples_axis_dim2_axis0_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim2_axis0_2) {
  const Model model = softmax_v1_2::createTestModel_axis_dim2_axis0_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim2_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim2_axis0_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim2_axis0_neg_2,
                           softmax_v1_2::is_ignored_axis_dim2_axis0_neg_2,
                           softmax_v1_2::get_examples_axis_dim2_axis0_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim2_axis0_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_dim2_axis0_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim2_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim2_axis1_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim2_axis1_2,
                           softmax_v1_2::is_ignored_axis_dim2_axis1_2,
                           softmax_v1_2::get_examples_axis_dim2_axis1_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim2_axis1_2) {
  const Model model = softmax_v1_2::createTestModel_axis_dim2_axis1_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim2_axis1_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim2_axis1_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim2_axis1_neg_2,
                           softmax_v1_2::is_ignored_axis_dim2_axis1_neg_2,
                           softmax_v1_2::get_examples_axis_dim2_axis1_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim2_axis1_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_dim2_axis1_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim2_axis1_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim1_axis0_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim1_axis0_2,
                           softmax_v1_2::is_ignored_axis_dim1_axis0_2,
                           softmax_v1_2::get_examples_axis_dim1_axis0_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim1_axis0_2) {
  const Model model = softmax_v1_2::createTestModel_axis_dim1_axis0_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim1_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_dim1_axis0_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_dim1_axis0_neg_2,
                           softmax_v1_2::is_ignored_axis_dim1_axis0_neg_2,
                           softmax_v1_2::get_examples_axis_dim1_axis0_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_dim1_axis0_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_dim1_axis0_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_dim1_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim4_axis0_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim4_axis0_2,
                           softmax_v1_2::is_ignored_axis_relaxed_dim4_axis0_2,
                           softmax_v1_2::get_examples_axis_relaxed_dim4_axis0_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim4_axis0_2) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim4_axis0_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim4_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim4_axis0_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim4_axis0_neg_2,
                           softmax_v1_2::is_ignored_axis_relaxed_dim4_axis0_neg_2,
                           softmax_v1_2::get_examples_axis_relaxed_dim4_axis0_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim4_axis0_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim4_axis0_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim4_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim4_axis1_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim4_axis1_2,
                           softmax_v1_2::is_ignored_axis_relaxed_dim4_axis1_2,
                           softmax_v1_2::get_examples_axis_relaxed_dim4_axis1_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim4_axis1_2) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim4_axis1_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim4_axis1_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim4_axis1_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim4_axis1_neg_2,
                           softmax_v1_2::is_ignored_axis_relaxed_dim4_axis1_neg_2,
                           softmax_v1_2::get_examples_axis_relaxed_dim4_axis1_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim4_axis1_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim4_axis1_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim4_axis1_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim4_axis2_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim4_axis2_2,
                           softmax_v1_2::is_ignored_axis_relaxed_dim4_axis2_2,
                           softmax_v1_2::get_examples_axis_relaxed_dim4_axis2_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim4_axis2_2) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim4_axis2_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim4_axis2_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim4_axis2_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim4_axis2_neg_2,
                           softmax_v1_2::is_ignored_axis_relaxed_dim4_axis2_neg_2,
                           softmax_v1_2::get_examples_axis_relaxed_dim4_axis2_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim4_axis2_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim4_axis2_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim4_axis2_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim4_axis3_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim4_axis3_2,
                           softmax_v1_2::is_ignored_axis_relaxed_dim4_axis3_2,
                           softmax_v1_2::get_examples_axis_relaxed_dim4_axis3_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim4_axis3_2) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim4_axis3_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim4_axis3_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim4_axis3_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim4_axis3_neg_2,
                           softmax_v1_2::is_ignored_axis_relaxed_dim4_axis3_neg_2,
                           softmax_v1_2::get_examples_axis_relaxed_dim4_axis3_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim4_axis3_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim4_axis3_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim4_axis3_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim3_axis0_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim3_axis0_2,
                           softmax_v1_2::is_ignored_axis_relaxed_dim3_axis0_2,
                           softmax_v1_2::get_examples_axis_relaxed_dim3_axis0_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim3_axis0_2) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim3_axis0_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim3_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim3_axis0_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim3_axis0_neg_2,
                           softmax_v1_2::is_ignored_axis_relaxed_dim3_axis0_neg_2,
                           softmax_v1_2::get_examples_axis_relaxed_dim3_axis0_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim3_axis0_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim3_axis0_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim3_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim3_axis1_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim3_axis1_2,
                           softmax_v1_2::is_ignored_axis_relaxed_dim3_axis1_2,
                           softmax_v1_2::get_examples_axis_relaxed_dim3_axis1_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim3_axis1_2) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim3_axis1_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim3_axis1_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim3_axis1_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim3_axis1_neg_2,
                           softmax_v1_2::is_ignored_axis_relaxed_dim3_axis1_neg_2,
                           softmax_v1_2::get_examples_axis_relaxed_dim3_axis1_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim3_axis1_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim3_axis1_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim3_axis1_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim3_axis2_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim3_axis2_2,
                           softmax_v1_2::is_ignored_axis_relaxed_dim3_axis2_2,
                           softmax_v1_2::get_examples_axis_relaxed_dim3_axis2_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim3_axis2_2) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim3_axis2_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim3_axis2_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim3_axis2_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim3_axis2_neg_2,
                           softmax_v1_2::is_ignored_axis_relaxed_dim3_axis2_neg_2,
                           softmax_v1_2::get_examples_axis_relaxed_dim3_axis2_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim3_axis2_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim3_axis2_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim3_axis2_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim2_axis0_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim2_axis0_2,
                           softmax_v1_2::is_ignored_axis_relaxed_dim2_axis0_2,
                           softmax_v1_2::get_examples_axis_relaxed_dim2_axis0_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim2_axis0_2) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim2_axis0_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim2_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim2_axis0_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim2_axis0_neg_2,
                           softmax_v1_2::is_ignored_axis_relaxed_dim2_axis0_neg_2,
                           softmax_v1_2::get_examples_axis_relaxed_dim2_axis0_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim2_axis0_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim2_axis0_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim2_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim2_axis1_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim2_axis1_2,
                           softmax_v1_2::is_ignored_axis_relaxed_dim2_axis1_2,
                           softmax_v1_2::get_examples_axis_relaxed_dim2_axis1_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim2_axis1_2) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim2_axis1_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim2_axis1_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim2_axis1_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim2_axis1_neg_2,
                           softmax_v1_2::is_ignored_axis_relaxed_dim2_axis1_neg_2,
                           softmax_v1_2::get_examples_axis_relaxed_dim2_axis1_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim2_axis1_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim2_axis1_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim2_axis1_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim1_axis0_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim1_axis0_2,
                           softmax_v1_2::is_ignored_axis_relaxed_dim1_axis0_2,
                           softmax_v1_2::get_examples_axis_relaxed_dim1_axis0_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim1_axis0_2) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim1_axis0_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim1_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_relaxed_dim1_axis0_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_relaxed_dim1_axis0_neg_2,
                           softmax_v1_2::is_ignored_axis_relaxed_dim1_axis0_neg_2,
                           softmax_v1_2::get_examples_axis_relaxed_dim1_axis0_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_relaxed_dim1_axis0_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_relaxed_dim1_axis0_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_relaxed_dim1_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim4_axis0_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim4_axis0_2,
                           softmax_v1_2::is_ignored_axis_float16_dim4_axis0_2,
                           softmax_v1_2::get_examples_axis_float16_dim4_axis0_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim4_axis0_2) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim4_axis0_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim4_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim4_axis0_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim4_axis0_neg_2,
                           softmax_v1_2::is_ignored_axis_float16_dim4_axis0_neg_2,
                           softmax_v1_2::get_examples_axis_float16_dim4_axis0_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim4_axis0_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim4_axis0_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim4_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim4_axis1_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim4_axis1_2,
                           softmax_v1_2::is_ignored_axis_float16_dim4_axis1_2,
                           softmax_v1_2::get_examples_axis_float16_dim4_axis1_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim4_axis1_2) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim4_axis1_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim4_axis1_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim4_axis1_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim4_axis1_neg_2,
                           softmax_v1_2::is_ignored_axis_float16_dim4_axis1_neg_2,
                           softmax_v1_2::get_examples_axis_float16_dim4_axis1_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim4_axis1_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim4_axis1_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim4_axis1_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim4_axis2_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim4_axis2_2,
                           softmax_v1_2::is_ignored_axis_float16_dim4_axis2_2,
                           softmax_v1_2::get_examples_axis_float16_dim4_axis2_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim4_axis2_2) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim4_axis2_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim4_axis2_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim4_axis2_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim4_axis2_neg_2,
                           softmax_v1_2::is_ignored_axis_float16_dim4_axis2_neg_2,
                           softmax_v1_2::get_examples_axis_float16_dim4_axis2_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim4_axis2_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim4_axis2_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim4_axis2_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim4_axis3_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim4_axis3_2,
                           softmax_v1_2::is_ignored_axis_float16_dim4_axis3_2,
                           softmax_v1_2::get_examples_axis_float16_dim4_axis3_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim4_axis3_2) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim4_axis3_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim4_axis3_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim4_axis3_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim4_axis3_neg_2,
                           softmax_v1_2::is_ignored_axis_float16_dim4_axis3_neg_2,
                           softmax_v1_2::get_examples_axis_float16_dim4_axis3_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim4_axis3_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim4_axis3_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim4_axis3_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim3_axis0_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim3_axis0_2,
                           softmax_v1_2::is_ignored_axis_float16_dim3_axis0_2,
                           softmax_v1_2::get_examples_axis_float16_dim3_axis0_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim3_axis0_2) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim3_axis0_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim3_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim3_axis0_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim3_axis0_neg_2,
                           softmax_v1_2::is_ignored_axis_float16_dim3_axis0_neg_2,
                           softmax_v1_2::get_examples_axis_float16_dim3_axis0_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim3_axis0_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim3_axis0_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim3_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim3_axis1_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim3_axis1_2,
                           softmax_v1_2::is_ignored_axis_float16_dim3_axis1_2,
                           softmax_v1_2::get_examples_axis_float16_dim3_axis1_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim3_axis1_2) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim3_axis1_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim3_axis1_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim3_axis1_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim3_axis1_neg_2,
                           softmax_v1_2::is_ignored_axis_float16_dim3_axis1_neg_2,
                           softmax_v1_2::get_examples_axis_float16_dim3_axis1_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim3_axis1_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim3_axis1_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim3_axis1_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim3_axis2_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim3_axis2_2,
                           softmax_v1_2::is_ignored_axis_float16_dim3_axis2_2,
                           softmax_v1_2::get_examples_axis_float16_dim3_axis2_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim3_axis2_2) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim3_axis2_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim3_axis2_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim3_axis2_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim3_axis2_neg_2,
                           softmax_v1_2::is_ignored_axis_float16_dim3_axis2_neg_2,
                           softmax_v1_2::get_examples_axis_float16_dim3_axis2_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim3_axis2_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim3_axis2_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim3_axis2_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim2_axis0_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim2_axis0_2,
                           softmax_v1_2::is_ignored_axis_float16_dim2_axis0_2,
                           softmax_v1_2::get_examples_axis_float16_dim2_axis0_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim2_axis0_2) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim2_axis0_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim2_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim2_axis0_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim2_axis0_neg_2,
                           softmax_v1_2::is_ignored_axis_float16_dim2_axis0_neg_2,
                           softmax_v1_2::get_examples_axis_float16_dim2_axis0_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim2_axis0_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim2_axis0_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim2_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim2_axis1_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim2_axis1_2,
                           softmax_v1_2::is_ignored_axis_float16_dim2_axis1_2,
                           softmax_v1_2::get_examples_axis_float16_dim2_axis1_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim2_axis1_2) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim2_axis1_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim2_axis1_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim2_axis1_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim2_axis1_neg_2,
                           softmax_v1_2::is_ignored_axis_float16_dim2_axis1_neg_2,
                           softmax_v1_2::get_examples_axis_float16_dim2_axis1_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim2_axis1_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim2_axis1_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim2_axis1_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim1_axis0_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim1_axis0_2,
                           softmax_v1_2::is_ignored_axis_float16_dim1_axis0_2,
                           softmax_v1_2::get_examples_axis_float16_dim1_axis0_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim1_axis0_2) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim1_axis0_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim1_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_float16_dim1_axis0_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_float16_dim1_axis0_neg_2,
                           softmax_v1_2::is_ignored_axis_float16_dim1_axis0_neg_2,
                           softmax_v1_2::get_examples_axis_float16_dim1_axis0_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_float16_dim1_axis0_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_float16_dim1_axis0_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_float16_dim1_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim4_axis0_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim4_axis0_2,
                           softmax_v1_2::is_ignored_axis_quant8_dim4_axis0_2,
                           softmax_v1_2::get_examples_axis_quant8_dim4_axis0_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim4_axis0_2) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim4_axis0_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim4_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim4_axis0_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim4_axis0_neg_2,
                           softmax_v1_2::is_ignored_axis_quant8_dim4_axis0_neg_2,
                           softmax_v1_2::get_examples_axis_quant8_dim4_axis0_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim4_axis0_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim4_axis0_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim4_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim4_axis1_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim4_axis1_2,
                           softmax_v1_2::is_ignored_axis_quant8_dim4_axis1_2,
                           softmax_v1_2::get_examples_axis_quant8_dim4_axis1_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim4_axis1_2) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim4_axis1_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim4_axis1_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim4_axis1_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim4_axis1_neg_2,
                           softmax_v1_2::is_ignored_axis_quant8_dim4_axis1_neg_2,
                           softmax_v1_2::get_examples_axis_quant8_dim4_axis1_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim4_axis1_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim4_axis1_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim4_axis1_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim4_axis2_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim4_axis2_2,
                           softmax_v1_2::is_ignored_axis_quant8_dim4_axis2_2,
                           softmax_v1_2::get_examples_axis_quant8_dim4_axis2_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim4_axis2_2) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim4_axis2_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim4_axis2_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim4_axis2_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim4_axis2_neg_2,
                           softmax_v1_2::is_ignored_axis_quant8_dim4_axis2_neg_2,
                           softmax_v1_2::get_examples_axis_quant8_dim4_axis2_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim4_axis2_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim4_axis2_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim4_axis2_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim4_axis3_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim4_axis3_2,
                           softmax_v1_2::is_ignored_axis_quant8_dim4_axis3_2,
                           softmax_v1_2::get_examples_axis_quant8_dim4_axis3_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim4_axis3_2) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim4_axis3_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim4_axis3_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim4_axis3_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim4_axis3_neg_2,
                           softmax_v1_2::is_ignored_axis_quant8_dim4_axis3_neg_2,
                           softmax_v1_2::get_examples_axis_quant8_dim4_axis3_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim4_axis3_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim4_axis3_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim4_axis3_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim3_axis0_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim3_axis0_2,
                           softmax_v1_2::is_ignored_axis_quant8_dim3_axis0_2,
                           softmax_v1_2::get_examples_axis_quant8_dim3_axis0_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim3_axis0_2) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim3_axis0_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim3_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim3_axis0_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim3_axis0_neg_2,
                           softmax_v1_2::is_ignored_axis_quant8_dim3_axis0_neg_2,
                           softmax_v1_2::get_examples_axis_quant8_dim3_axis0_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim3_axis0_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim3_axis0_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim3_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim3_axis1_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim3_axis1_2,
                           softmax_v1_2::is_ignored_axis_quant8_dim3_axis1_2,
                           softmax_v1_2::get_examples_axis_quant8_dim3_axis1_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim3_axis1_2) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim3_axis1_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim3_axis1_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim3_axis1_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim3_axis1_neg_2,
                           softmax_v1_2::is_ignored_axis_quant8_dim3_axis1_neg_2,
                           softmax_v1_2::get_examples_axis_quant8_dim3_axis1_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim3_axis1_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim3_axis1_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim3_axis1_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim3_axis2_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim3_axis2_2,
                           softmax_v1_2::is_ignored_axis_quant8_dim3_axis2_2,
                           softmax_v1_2::get_examples_axis_quant8_dim3_axis2_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim3_axis2_2) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim3_axis2_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim3_axis2_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim3_axis2_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim3_axis2_neg_2,
                           softmax_v1_2::is_ignored_axis_quant8_dim3_axis2_neg_2,
                           softmax_v1_2::get_examples_axis_quant8_dim3_axis2_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim3_axis2_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim3_axis2_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim3_axis2_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim2_axis0_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim2_axis0_2,
                           softmax_v1_2::is_ignored_axis_quant8_dim2_axis0_2,
                           softmax_v1_2::get_examples_axis_quant8_dim2_axis0_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim2_axis0_2) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim2_axis0_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim2_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim2_axis0_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim2_axis0_neg_2,
                           softmax_v1_2::is_ignored_axis_quant8_dim2_axis0_neg_2,
                           softmax_v1_2::get_examples_axis_quant8_dim2_axis0_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim2_axis0_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim2_axis0_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim2_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim2_axis1_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim2_axis1_2,
                           softmax_v1_2::is_ignored_axis_quant8_dim2_axis1_2,
                           softmax_v1_2::get_examples_axis_quant8_dim2_axis1_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim2_axis1_2) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim2_axis1_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim2_axis1_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim2_axis1_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim2_axis1_neg_2,
                           softmax_v1_2::is_ignored_axis_quant8_dim2_axis1_neg_2,
                           softmax_v1_2::get_examples_axis_quant8_dim2_axis1_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim2_axis1_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim2_axis1_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim2_axis1_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim1_axis0_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim1_axis0_2,
                           softmax_v1_2::is_ignored_axis_quant8_dim1_axis0_2,
                           softmax_v1_2::get_examples_axis_quant8_dim1_axis0_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim1_axis0_2) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim1_axis0_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim1_axis0_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, softmax_v1_2_axis_quant8_dim1_axis0_neg_2) {
  generated_tests::Execute(device,
                           softmax_v1_2::createTestModel_axis_quant8_dim1_axis0_neg_2,
                           softmax_v1_2::is_ignored_axis_quant8_dim1_axis0_neg_2,
                           softmax_v1_2::get_examples_axis_quant8_dim1_axis0_neg_2());
}

TEST_F(ValidationTest, softmax_v1_2_axis_quant8_dim1_axis0_neg_2) {
  const Model model = softmax_v1_2::createTestModel_axis_quant8_dim1_axis0_neg_2();
  const std::vector<Request> requests = createRequests(softmax_v1_2::get_examples_axis_quant8_dim1_axis0_neg_2());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: space_to_batch_v1_2.mod.py.
namespace space_to_batch_v1_2 {
// Generated space_to_batch_v1_2 test
#include "examples/space_to_batch_v1_2.example.cpp"
// Generated model constructor
#include "vts_models/space_to_batch_v1_2.model.cpp"
} // namespace space_to_batch_v1_2

TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nhwc) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nhwc,
                           space_to_batch_v1_2::is_ignored_nhwc,
                           space_to_batch_v1_2::get_examples_nhwc());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nhwc) {
  const Model model = space_to_batch_v1_2::createTestModel_nhwc();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nhwc());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nhwc_relaxed) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nhwc_relaxed,
                           space_to_batch_v1_2::is_ignored_nhwc_relaxed,
                           space_to_batch_v1_2::get_examples_nhwc_relaxed());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nhwc_relaxed) {
  const Model model = space_to_batch_v1_2::createTestModel_nhwc_relaxed();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nhwc_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nhwc_float16) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nhwc_float16,
                           space_to_batch_v1_2::is_ignored_nhwc_float16,
                           space_to_batch_v1_2::get_examples_nhwc_float16());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nhwc_float16) {
  const Model model = space_to_batch_v1_2::createTestModel_nhwc_float16();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nhwc_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nhwc_quant8) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nhwc_quant8,
                           space_to_batch_v1_2::is_ignored_nhwc_quant8,
                           space_to_batch_v1_2::get_examples_nhwc_quant8());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nhwc_quant8) {
  const Model model = space_to_batch_v1_2::createTestModel_nhwc_quant8();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nhwc_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nchw) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nchw,
                           space_to_batch_v1_2::is_ignored_nchw,
                           space_to_batch_v1_2::get_examples_nchw());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nchw) {
  const Model model = space_to_batch_v1_2::createTestModel_nchw();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nchw());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nchw_relaxed) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nchw_relaxed,
                           space_to_batch_v1_2::is_ignored_nchw_relaxed,
                           space_to_batch_v1_2::get_examples_nchw_relaxed());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nchw_relaxed) {
  const Model model = space_to_batch_v1_2::createTestModel_nchw_relaxed();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nchw_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nchw_float16) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nchw_float16,
                           space_to_batch_v1_2::is_ignored_nchw_float16,
                           space_to_batch_v1_2::get_examples_nchw_float16());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nchw_float16) {
  const Model model = space_to_batch_v1_2::createTestModel_nchw_float16();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nchw_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nchw_quant8) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nchw_quant8,
                           space_to_batch_v1_2::is_ignored_nchw_quant8,
                           space_to_batch_v1_2::get_examples_nchw_quant8());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nchw_quant8) {
  const Model model = space_to_batch_v1_2::createTestModel_nchw_quant8();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nchw_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nhwc_2) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nhwc_2,
                           space_to_batch_v1_2::is_ignored_nhwc_2,
                           space_to_batch_v1_2::get_examples_nhwc_2());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nhwc_2) {
  const Model model = space_to_batch_v1_2::createTestModel_nhwc_2();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nhwc_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nhwc_relaxed_2) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nhwc_relaxed_2,
                           space_to_batch_v1_2::is_ignored_nhwc_relaxed_2,
                           space_to_batch_v1_2::get_examples_nhwc_relaxed_2());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nhwc_relaxed_2) {
  const Model model = space_to_batch_v1_2::createTestModel_nhwc_relaxed_2();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nhwc_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nhwc_float16_2) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nhwc_float16_2,
                           space_to_batch_v1_2::is_ignored_nhwc_float16_2,
                           space_to_batch_v1_2::get_examples_nhwc_float16_2());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nhwc_float16_2) {
  const Model model = space_to_batch_v1_2::createTestModel_nhwc_float16_2();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nhwc_float16_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nhwc_quant8_2) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nhwc_quant8_2,
                           space_to_batch_v1_2::is_ignored_nhwc_quant8_2,
                           space_to_batch_v1_2::get_examples_nhwc_quant8_2());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nhwc_quant8_2) {
  const Model model = space_to_batch_v1_2::createTestModel_nhwc_quant8_2();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nhwc_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nchw_2) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nchw_2,
                           space_to_batch_v1_2::is_ignored_nchw_2,
                           space_to_batch_v1_2::get_examples_nchw_2());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nchw_2) {
  const Model model = space_to_batch_v1_2::createTestModel_nchw_2();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nchw_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nchw_relaxed_2) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nchw_relaxed_2,
                           space_to_batch_v1_2::is_ignored_nchw_relaxed_2,
                           space_to_batch_v1_2::get_examples_nchw_relaxed_2());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nchw_relaxed_2) {
  const Model model = space_to_batch_v1_2::createTestModel_nchw_relaxed_2();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nchw_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nchw_float16_2) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nchw_float16_2,
                           space_to_batch_v1_2::is_ignored_nchw_float16_2,
                           space_to_batch_v1_2::get_examples_nchw_float16_2());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nchw_float16_2) {
  const Model model = space_to_batch_v1_2::createTestModel_nchw_float16_2();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nchw_float16_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nchw_quant8_2) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nchw_quant8_2,
                           space_to_batch_v1_2::is_ignored_nchw_quant8_2,
                           space_to_batch_v1_2::get_examples_nchw_quant8_2());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nchw_quant8_2) {
  const Model model = space_to_batch_v1_2::createTestModel_nchw_quant8_2();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nchw_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nhwc_3) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nhwc_3,
                           space_to_batch_v1_2::is_ignored_nhwc_3,
                           space_to_batch_v1_2::get_examples_nhwc_3());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nhwc_3) {
  const Model model = space_to_batch_v1_2::createTestModel_nhwc_3();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nhwc_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nhwc_relaxed_3) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nhwc_relaxed_3,
                           space_to_batch_v1_2::is_ignored_nhwc_relaxed_3,
                           space_to_batch_v1_2::get_examples_nhwc_relaxed_3());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nhwc_relaxed_3) {
  const Model model = space_to_batch_v1_2::createTestModel_nhwc_relaxed_3();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nhwc_relaxed_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nhwc_float16_3) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nhwc_float16_3,
                           space_to_batch_v1_2::is_ignored_nhwc_float16_3,
                           space_to_batch_v1_2::get_examples_nhwc_float16_3());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nhwc_float16_3) {
  const Model model = space_to_batch_v1_2::createTestModel_nhwc_float16_3();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nhwc_float16_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nhwc_quant8_3) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nhwc_quant8_3,
                           space_to_batch_v1_2::is_ignored_nhwc_quant8_3,
                           space_to_batch_v1_2::get_examples_nhwc_quant8_3());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nhwc_quant8_3) {
  const Model model = space_to_batch_v1_2::createTestModel_nhwc_quant8_3();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nhwc_quant8_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nchw_3) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nchw_3,
                           space_to_batch_v1_2::is_ignored_nchw_3,
                           space_to_batch_v1_2::get_examples_nchw_3());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nchw_3) {
  const Model model = space_to_batch_v1_2::createTestModel_nchw_3();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nchw_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nchw_relaxed_3) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nchw_relaxed_3,
                           space_to_batch_v1_2::is_ignored_nchw_relaxed_3,
                           space_to_batch_v1_2::get_examples_nchw_relaxed_3());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nchw_relaxed_3) {
  const Model model = space_to_batch_v1_2::createTestModel_nchw_relaxed_3();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nchw_relaxed_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nchw_float16_3) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nchw_float16_3,
                           space_to_batch_v1_2::is_ignored_nchw_float16_3,
                           space_to_batch_v1_2::get_examples_nchw_float16_3());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nchw_float16_3) {
  const Model model = space_to_batch_v1_2::createTestModel_nchw_float16_3();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nchw_float16_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nchw_quant8_3) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nchw_quant8_3,
                           space_to_batch_v1_2::is_ignored_nchw_quant8_3,
                           space_to_batch_v1_2::get_examples_nchw_quant8_3());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nchw_quant8_3) {
  const Model model = space_to_batch_v1_2::createTestModel_nchw_quant8_3();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nchw_quant8_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nhwc_4) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nhwc_4,
                           space_to_batch_v1_2::is_ignored_nhwc_4,
                           space_to_batch_v1_2::get_examples_nhwc_4());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nhwc_4) {
  const Model model = space_to_batch_v1_2::createTestModel_nhwc_4();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nhwc_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nhwc_relaxed_4) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nhwc_relaxed_4,
                           space_to_batch_v1_2::is_ignored_nhwc_relaxed_4,
                           space_to_batch_v1_2::get_examples_nhwc_relaxed_4());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nhwc_relaxed_4) {
  const Model model = space_to_batch_v1_2::createTestModel_nhwc_relaxed_4();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nhwc_relaxed_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nhwc_float16_4) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nhwc_float16_4,
                           space_to_batch_v1_2::is_ignored_nhwc_float16_4,
                           space_to_batch_v1_2::get_examples_nhwc_float16_4());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nhwc_float16_4) {
  const Model model = space_to_batch_v1_2::createTestModel_nhwc_float16_4();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nhwc_float16_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nhwc_quant8_4) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nhwc_quant8_4,
                           space_to_batch_v1_2::is_ignored_nhwc_quant8_4,
                           space_to_batch_v1_2::get_examples_nhwc_quant8_4());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nhwc_quant8_4) {
  const Model model = space_to_batch_v1_2::createTestModel_nhwc_quant8_4();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nhwc_quant8_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nchw_4) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nchw_4,
                           space_to_batch_v1_2::is_ignored_nchw_4,
                           space_to_batch_v1_2::get_examples_nchw_4());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nchw_4) {
  const Model model = space_to_batch_v1_2::createTestModel_nchw_4();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nchw_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nchw_relaxed_4) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nchw_relaxed_4,
                           space_to_batch_v1_2::is_ignored_nchw_relaxed_4,
                           space_to_batch_v1_2::get_examples_nchw_relaxed_4());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nchw_relaxed_4) {
  const Model model = space_to_batch_v1_2::createTestModel_nchw_relaxed_4();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nchw_relaxed_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nchw_float16_4) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nchw_float16_4,
                           space_to_batch_v1_2::is_ignored_nchw_float16_4,
                           space_to_batch_v1_2::get_examples_nchw_float16_4());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nchw_float16_4) {
  const Model model = space_to_batch_v1_2::createTestModel_nchw_float16_4();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nchw_float16_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_batch_v1_2_nchw_quant8_4) {
  generated_tests::Execute(device,
                           space_to_batch_v1_2::createTestModel_nchw_quant8_4,
                           space_to_batch_v1_2::is_ignored_nchw_quant8_4,
                           space_to_batch_v1_2::get_examples_nchw_quant8_4());
}

TEST_F(ValidationTest, space_to_batch_v1_2_nchw_quant8_4) {
  const Model model = space_to_batch_v1_2::createTestModel_nchw_quant8_4();
  const std::vector<Request> requests = createRequests(space_to_batch_v1_2::get_examples_nchw_quant8_4());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: space_to_depth_v1_2.mod.py.
namespace space_to_depth_v1_2 {
// Generated space_to_depth_v1_2 test
#include "examples/space_to_depth_v1_2.example.cpp"
// Generated model constructor
#include "vts_models/space_to_depth_v1_2.model.cpp"
} // namespace space_to_depth_v1_2

TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nhwc) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nhwc,
                           space_to_depth_v1_2::is_ignored_nhwc,
                           space_to_depth_v1_2::get_examples_nhwc());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nhwc) {
  const Model model = space_to_depth_v1_2::createTestModel_nhwc();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nhwc());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nhwc_relaxed) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nhwc_relaxed,
                           space_to_depth_v1_2::is_ignored_nhwc_relaxed,
                           space_to_depth_v1_2::get_examples_nhwc_relaxed());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nhwc_relaxed) {
  const Model model = space_to_depth_v1_2::createTestModel_nhwc_relaxed();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nhwc_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nhwc_float16) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nhwc_float16,
                           space_to_depth_v1_2::is_ignored_nhwc_float16,
                           space_to_depth_v1_2::get_examples_nhwc_float16());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nhwc_float16) {
  const Model model = space_to_depth_v1_2::createTestModel_nhwc_float16();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nhwc_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nhwc_quant8) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nhwc_quant8,
                           space_to_depth_v1_2::is_ignored_nhwc_quant8,
                           space_to_depth_v1_2::get_examples_nhwc_quant8());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nhwc_quant8) {
  const Model model = space_to_depth_v1_2::createTestModel_nhwc_quant8();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nhwc_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nchw) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nchw,
                           space_to_depth_v1_2::is_ignored_nchw,
                           space_to_depth_v1_2::get_examples_nchw());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nchw) {
  const Model model = space_to_depth_v1_2::createTestModel_nchw();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nchw());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nchw_relaxed) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nchw_relaxed,
                           space_to_depth_v1_2::is_ignored_nchw_relaxed,
                           space_to_depth_v1_2::get_examples_nchw_relaxed());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nchw_relaxed) {
  const Model model = space_to_depth_v1_2::createTestModel_nchw_relaxed();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nchw_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nchw_float16) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nchw_float16,
                           space_to_depth_v1_2::is_ignored_nchw_float16,
                           space_to_depth_v1_2::get_examples_nchw_float16());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nchw_float16) {
  const Model model = space_to_depth_v1_2::createTestModel_nchw_float16();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nchw_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nchw_quant8) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nchw_quant8,
                           space_to_depth_v1_2::is_ignored_nchw_quant8,
                           space_to_depth_v1_2::get_examples_nchw_quant8());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nchw_quant8) {
  const Model model = space_to_depth_v1_2::createTestModel_nchw_quant8();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nchw_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nhwc_2) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nhwc_2,
                           space_to_depth_v1_2::is_ignored_nhwc_2,
                           space_to_depth_v1_2::get_examples_nhwc_2());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nhwc_2) {
  const Model model = space_to_depth_v1_2::createTestModel_nhwc_2();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nhwc_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nhwc_relaxed_2) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nhwc_relaxed_2,
                           space_to_depth_v1_2::is_ignored_nhwc_relaxed_2,
                           space_to_depth_v1_2::get_examples_nhwc_relaxed_2());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nhwc_relaxed_2) {
  const Model model = space_to_depth_v1_2::createTestModel_nhwc_relaxed_2();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nhwc_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nhwc_float16_2) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nhwc_float16_2,
                           space_to_depth_v1_2::is_ignored_nhwc_float16_2,
                           space_to_depth_v1_2::get_examples_nhwc_float16_2());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nhwc_float16_2) {
  const Model model = space_to_depth_v1_2::createTestModel_nhwc_float16_2();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nhwc_float16_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nhwc_quant8_2) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nhwc_quant8_2,
                           space_to_depth_v1_2::is_ignored_nhwc_quant8_2,
                           space_to_depth_v1_2::get_examples_nhwc_quant8_2());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nhwc_quant8_2) {
  const Model model = space_to_depth_v1_2::createTestModel_nhwc_quant8_2();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nhwc_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nchw_2) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nchw_2,
                           space_to_depth_v1_2::is_ignored_nchw_2,
                           space_to_depth_v1_2::get_examples_nchw_2());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nchw_2) {
  const Model model = space_to_depth_v1_2::createTestModel_nchw_2();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nchw_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nchw_relaxed_2) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nchw_relaxed_2,
                           space_to_depth_v1_2::is_ignored_nchw_relaxed_2,
                           space_to_depth_v1_2::get_examples_nchw_relaxed_2());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nchw_relaxed_2) {
  const Model model = space_to_depth_v1_2::createTestModel_nchw_relaxed_2();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nchw_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nchw_float16_2) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nchw_float16_2,
                           space_to_depth_v1_2::is_ignored_nchw_float16_2,
                           space_to_depth_v1_2::get_examples_nchw_float16_2());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nchw_float16_2) {
  const Model model = space_to_depth_v1_2::createTestModel_nchw_float16_2();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nchw_float16_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nchw_quant8_2) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nchw_quant8_2,
                           space_to_depth_v1_2::is_ignored_nchw_quant8_2,
                           space_to_depth_v1_2::get_examples_nchw_quant8_2());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nchw_quant8_2) {
  const Model model = space_to_depth_v1_2::createTestModel_nchw_quant8_2();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nchw_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nhwc_3) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nhwc_3,
                           space_to_depth_v1_2::is_ignored_nhwc_3,
                           space_to_depth_v1_2::get_examples_nhwc_3());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nhwc_3) {
  const Model model = space_to_depth_v1_2::createTestModel_nhwc_3();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nhwc_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nhwc_relaxed_3) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nhwc_relaxed_3,
                           space_to_depth_v1_2::is_ignored_nhwc_relaxed_3,
                           space_to_depth_v1_2::get_examples_nhwc_relaxed_3());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nhwc_relaxed_3) {
  const Model model = space_to_depth_v1_2::createTestModel_nhwc_relaxed_3();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nhwc_relaxed_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nhwc_float16_3) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nhwc_float16_3,
                           space_to_depth_v1_2::is_ignored_nhwc_float16_3,
                           space_to_depth_v1_2::get_examples_nhwc_float16_3());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nhwc_float16_3) {
  const Model model = space_to_depth_v1_2::createTestModel_nhwc_float16_3();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nhwc_float16_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nhwc_quant8_3) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nhwc_quant8_3,
                           space_to_depth_v1_2::is_ignored_nhwc_quant8_3,
                           space_to_depth_v1_2::get_examples_nhwc_quant8_3());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nhwc_quant8_3) {
  const Model model = space_to_depth_v1_2::createTestModel_nhwc_quant8_3();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nhwc_quant8_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nchw_3) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nchw_3,
                           space_to_depth_v1_2::is_ignored_nchw_3,
                           space_to_depth_v1_2::get_examples_nchw_3());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nchw_3) {
  const Model model = space_to_depth_v1_2::createTestModel_nchw_3();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nchw_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nchw_relaxed_3) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nchw_relaxed_3,
                           space_to_depth_v1_2::is_ignored_nchw_relaxed_3,
                           space_to_depth_v1_2::get_examples_nchw_relaxed_3());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nchw_relaxed_3) {
  const Model model = space_to_depth_v1_2::createTestModel_nchw_relaxed_3();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nchw_relaxed_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nchw_float16_3) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nchw_float16_3,
                           space_to_depth_v1_2::is_ignored_nchw_float16_3,
                           space_to_depth_v1_2::get_examples_nchw_float16_3());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nchw_float16_3) {
  const Model model = space_to_depth_v1_2::createTestModel_nchw_float16_3();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nchw_float16_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, space_to_depth_v1_2_nchw_quant8_3) {
  generated_tests::Execute(device,
                           space_to_depth_v1_2::createTestModel_nchw_quant8_3,
                           space_to_depth_v1_2::is_ignored_nchw_quant8_3,
                           space_to_depth_v1_2::get_examples_nchw_quant8_3());
}

TEST_F(ValidationTest, space_to_depth_v1_2_nchw_quant8_3) {
  const Model model = space_to_depth_v1_2::createTestModel_nchw_quant8_3();
  const std::vector<Request> requests = createRequests(space_to_depth_v1_2::get_examples_nchw_quant8_3());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: split_float_1.mod.py.
namespace split_float_1 {
// Generated split_float_1 test
#include "examples/split_float_1.example.cpp"
// Generated model constructor
#include "vts_models/split_float_1.model.cpp"
} // namespace split_float_1

TEST_F(NeuralnetworksHidlTest, split_float_1) {
  generated_tests::Execute(device,
                           split_float_1::createTestModel,
                           split_float_1::is_ignored,
                           split_float_1::get_examples());
}

TEST_F(ValidationTest, split_float_1) {
  const Model model = split_float_1::createTestModel();
  const std::vector<Request> requests = createRequests(split_float_1::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, split_float_1_relaxed) {
  generated_tests::Execute(device,
                           split_float_1::createTestModel_relaxed,
                           split_float_1::is_ignored_relaxed,
                           split_float_1::get_examples_relaxed());
}

TEST_F(ValidationTest, split_float_1_relaxed) {
  const Model model = split_float_1::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(split_float_1::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, split_float_1_float16) {
  generated_tests::Execute(device,
                           split_float_1::createTestModel_float16,
                           split_float_1::is_ignored_float16,
                           split_float_1::get_examples_float16());
}

TEST_F(ValidationTest, split_float_1_float16) {
  const Model model = split_float_1::createTestModel_float16();
  const std::vector<Request> requests = createRequests(split_float_1::get_examples_float16());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: split_float_2.mod.py.
namespace split_float_2 {
// Generated split_float_2 test
#include "examples/split_float_2.example.cpp"
// Generated model constructor
#include "vts_models/split_float_2.model.cpp"
} // namespace split_float_2

TEST_F(NeuralnetworksHidlTest, split_float_2) {
  generated_tests::Execute(device,
                           split_float_2::createTestModel,
                           split_float_2::is_ignored,
                           split_float_2::get_examples());
}

TEST_F(ValidationTest, split_float_2) {
  const Model model = split_float_2::createTestModel();
  const std::vector<Request> requests = createRequests(split_float_2::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, split_float_2_relaxed) {
  generated_tests::Execute(device,
                           split_float_2::createTestModel_relaxed,
                           split_float_2::is_ignored_relaxed,
                           split_float_2::get_examples_relaxed());
}

TEST_F(ValidationTest, split_float_2_relaxed) {
  const Model model = split_float_2::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(split_float_2::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, split_float_2_float16) {
  generated_tests::Execute(device,
                           split_float_2::createTestModel_float16,
                           split_float_2::is_ignored_float16,
                           split_float_2::get_examples_float16());
}

TEST_F(ValidationTest, split_float_2_float16) {
  const Model model = split_float_2::createTestModel_float16();
  const std::vector<Request> requests = createRequests(split_float_2::get_examples_float16());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: split_float_3.mod.py.
namespace split_float_3 {
// Generated split_float_3 test
#include "examples/split_float_3.example.cpp"
// Generated model constructor
#include "vts_models/split_float_3.model.cpp"
} // namespace split_float_3

TEST_F(NeuralnetworksHidlTest, split_float_3) {
  generated_tests::Execute(device,
                           split_float_3::createTestModel,
                           split_float_3::is_ignored,
                           split_float_3::get_examples());
}

TEST_F(ValidationTest, split_float_3) {
  const Model model = split_float_3::createTestModel();
  const std::vector<Request> requests = createRequests(split_float_3::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, split_float_3_relaxed) {
  generated_tests::Execute(device,
                           split_float_3::createTestModel_relaxed,
                           split_float_3::is_ignored_relaxed,
                           split_float_3::get_examples_relaxed());
}

TEST_F(ValidationTest, split_float_3_relaxed) {
  const Model model = split_float_3::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(split_float_3::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, split_float_3_float16) {
  generated_tests::Execute(device,
                           split_float_3::createTestModel_float16,
                           split_float_3::is_ignored_float16,
                           split_float_3::get_examples_float16());
}

TEST_F(ValidationTest, split_float_3_float16) {
  const Model model = split_float_3::createTestModel_float16();
  const std::vector<Request> requests = createRequests(split_float_3::get_examples_float16());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: split_float_4.mod.py.
namespace split_float_4 {
// Generated split_float_4 test
#include "examples/split_float_4.example.cpp"
// Generated model constructor
#include "vts_models/split_float_4.model.cpp"
} // namespace split_float_4

TEST_F(NeuralnetworksHidlTest, split_float_4) {
  generated_tests::Execute(device,
                           split_float_4::createTestModel,
                           split_float_4::is_ignored,
                           split_float_4::get_examples());
}

TEST_F(ValidationTest, split_float_4) {
  const Model model = split_float_4::createTestModel();
  const std::vector<Request> requests = createRequests(split_float_4::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, split_float_4_relaxed) {
  generated_tests::Execute(device,
                           split_float_4::createTestModel_relaxed,
                           split_float_4::is_ignored_relaxed,
                           split_float_4::get_examples_relaxed());
}

TEST_F(ValidationTest, split_float_4_relaxed) {
  const Model model = split_float_4::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(split_float_4::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, split_float_4_float16) {
  generated_tests::Execute(device,
                           split_float_4::createTestModel_float16,
                           split_float_4::is_ignored_float16,
                           split_float_4::get_examples_float16());
}

TEST_F(ValidationTest, split_float_4_float16) {
  const Model model = split_float_4::createTestModel_float16();
  const std::vector<Request> requests = createRequests(split_float_4::get_examples_float16());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: split_float_5.mod.py.
namespace split_float_5 {
// Generated split_float_5 test
#include "examples/split_float_5.example.cpp"
// Generated model constructor
#include "vts_models/split_float_5.model.cpp"
} // namespace split_float_5

TEST_F(NeuralnetworksHidlTest, split_float_5) {
  generated_tests::Execute(device,
                           split_float_5::createTestModel,
                           split_float_5::is_ignored,
                           split_float_5::get_examples());
}

TEST_F(ValidationTest, split_float_5) {
  const Model model = split_float_5::createTestModel();
  const std::vector<Request> requests = createRequests(split_float_5::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, split_float_5_relaxed) {
  generated_tests::Execute(device,
                           split_float_5::createTestModel_relaxed,
                           split_float_5::is_ignored_relaxed,
                           split_float_5::get_examples_relaxed());
}

TEST_F(ValidationTest, split_float_5_relaxed) {
  const Model model = split_float_5::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(split_float_5::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, split_float_5_float16) {
  generated_tests::Execute(device,
                           split_float_5::createTestModel_float16,
                           split_float_5::is_ignored_float16,
                           split_float_5::get_examples_float16());
}

TEST_F(ValidationTest, split_float_5_float16) {
  const Model model = split_float_5::createTestModel_float16();
  const std::vector<Request> requests = createRequests(split_float_5::get_examples_float16());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: split_int32_1.mod.py.
namespace split_int32_1 {
// Generated split_int32_1 test
#include "examples/split_int32_1.example.cpp"
// Generated model constructor
#include "vts_models/split_int32_1.model.cpp"
} // namespace split_int32_1

TEST_F(NeuralnetworksHidlTest, split_int32_1) {
  generated_tests::Execute(device,
                           split_int32_1::createTestModel,
                           split_int32_1::is_ignored,
                           split_int32_1::get_examples());
}

TEST_F(ValidationTest, split_int32_1) {
  const Model model = split_int32_1::createTestModel();
  const std::vector<Request> requests = createRequests(split_int32_1::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, split_int32_1_relaxed) {
  generated_tests::Execute(device,
                           split_int32_1::createTestModel_relaxed,
                           split_int32_1::is_ignored_relaxed,
                           split_int32_1::get_examples_relaxed());
}

TEST_F(ValidationTest, split_int32_1_relaxed) {
  const Model model = split_int32_1::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(split_int32_1::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: split_int32_2.mod.py.
namespace split_int32_2 {
// Generated split_int32_2 test
#include "examples/split_int32_2.example.cpp"
// Generated model constructor
#include "vts_models/split_int32_2.model.cpp"
} // namespace split_int32_2

TEST_F(NeuralnetworksHidlTest, split_int32_2) {
  generated_tests::Execute(device,
                           split_int32_2::createTestModel,
                           split_int32_2::is_ignored,
                           split_int32_2::get_examples());
}

TEST_F(ValidationTest, split_int32_2) {
  const Model model = split_int32_2::createTestModel();
  const std::vector<Request> requests = createRequests(split_int32_2::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, split_int32_2_relaxed) {
  generated_tests::Execute(device,
                           split_int32_2::createTestModel_relaxed,
                           split_int32_2::is_ignored_relaxed,
                           split_int32_2::get_examples_relaxed());
}

TEST_F(ValidationTest, split_int32_2_relaxed) {
  const Model model = split_int32_2::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(split_int32_2::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: split_int32_3.mod.py.
namespace split_int32_3 {
// Generated split_int32_3 test
#include "examples/split_int32_3.example.cpp"
// Generated model constructor
#include "vts_models/split_int32_3.model.cpp"
} // namespace split_int32_3

TEST_F(NeuralnetworksHidlTest, split_int32_3) {
  generated_tests::Execute(device,
                           split_int32_3::createTestModel,
                           split_int32_3::is_ignored,
                           split_int32_3::get_examples());
}

TEST_F(ValidationTest, split_int32_3) {
  const Model model = split_int32_3::createTestModel();
  const std::vector<Request> requests = createRequests(split_int32_3::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, split_int32_3_relaxed) {
  generated_tests::Execute(device,
                           split_int32_3::createTestModel_relaxed,
                           split_int32_3::is_ignored_relaxed,
                           split_int32_3::get_examples_relaxed());
}

TEST_F(ValidationTest, split_int32_3_relaxed) {
  const Model model = split_int32_3::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(split_int32_3::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: split_int32_4.mod.py.
namespace split_int32_4 {
// Generated split_int32_4 test
#include "examples/split_int32_4.example.cpp"
// Generated model constructor
#include "vts_models/split_int32_4.model.cpp"
} // namespace split_int32_4

TEST_F(NeuralnetworksHidlTest, split_int32_4) {
  generated_tests::Execute(device,
                           split_int32_4::createTestModel,
                           split_int32_4::is_ignored,
                           split_int32_4::get_examples());
}

TEST_F(ValidationTest, split_int32_4) {
  const Model model = split_int32_4::createTestModel();
  const std::vector<Request> requests = createRequests(split_int32_4::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, split_int32_4_relaxed) {
  generated_tests::Execute(device,
                           split_int32_4::createTestModel_relaxed,
                           split_int32_4::is_ignored_relaxed,
                           split_int32_4::get_examples_relaxed());
}

TEST_F(ValidationTest, split_int32_4_relaxed) {
  const Model model = split_int32_4::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(split_int32_4::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: split_quant8_1.mod.py.
namespace split_quant8_1 {
// Generated split_quant8_1 test
#include "examples/split_quant8_1.example.cpp"
// Generated model constructor
#include "vts_models/split_quant8_1.model.cpp"
} // namespace split_quant8_1

TEST_F(NeuralnetworksHidlTest, split_quant8_1) {
  generated_tests::Execute(device,
                           split_quant8_1::createTestModel,
                           split_quant8_1::is_ignored,
                           split_quant8_1::get_examples());
}

TEST_F(ValidationTest, split_quant8_1) {
  const Model model = split_quant8_1::createTestModel();
  const std::vector<Request> requests = createRequests(split_quant8_1::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, split_quant8_1_relaxed) {
  generated_tests::Execute(device,
                           split_quant8_1::createTestModel_relaxed,
                           split_quant8_1::is_ignored_relaxed,
                           split_quant8_1::get_examples_relaxed());
}

TEST_F(ValidationTest, split_quant8_1_relaxed) {
  const Model model = split_quant8_1::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(split_quant8_1::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: split_quant8_2.mod.py.
namespace split_quant8_2 {
// Generated split_quant8_2 test
#include "examples/split_quant8_2.example.cpp"
// Generated model constructor
#include "vts_models/split_quant8_2.model.cpp"
} // namespace split_quant8_2

TEST_F(NeuralnetworksHidlTest, split_quant8_2) {
  generated_tests::Execute(device,
                           split_quant8_2::createTestModel,
                           split_quant8_2::is_ignored,
                           split_quant8_2::get_examples());
}

TEST_F(ValidationTest, split_quant8_2) {
  const Model model = split_quant8_2::createTestModel();
  const std::vector<Request> requests = createRequests(split_quant8_2::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, split_quant8_2_relaxed) {
  generated_tests::Execute(device,
                           split_quant8_2::createTestModel_relaxed,
                           split_quant8_2::is_ignored_relaxed,
                           split_quant8_2::get_examples_relaxed());
}

TEST_F(ValidationTest, split_quant8_2_relaxed) {
  const Model model = split_quant8_2::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(split_quant8_2::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: split_quant8_3.mod.py.
namespace split_quant8_3 {
// Generated split_quant8_3 test
#include "examples/split_quant8_3.example.cpp"
// Generated model constructor
#include "vts_models/split_quant8_3.model.cpp"
} // namespace split_quant8_3

TEST_F(NeuralnetworksHidlTest, split_quant8_3) {
  generated_tests::Execute(device,
                           split_quant8_3::createTestModel,
                           split_quant8_3::is_ignored,
                           split_quant8_3::get_examples());
}

TEST_F(ValidationTest, split_quant8_3) {
  const Model model = split_quant8_3::createTestModel();
  const std::vector<Request> requests = createRequests(split_quant8_3::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: split_quant8_4.mod.py.
namespace split_quant8_4 {
// Generated split_quant8_4 test
#include "examples/split_quant8_4.example.cpp"
// Generated model constructor
#include "vts_models/split_quant8_4.model.cpp"
} // namespace split_quant8_4

TEST_F(NeuralnetworksHidlTest, split_quant8_4) {
  generated_tests::Execute(device,
                           split_quant8_4::createTestModel,
                           split_quant8_4::is_ignored,
                           split_quant8_4::get_examples());
}

TEST_F(ValidationTest, split_quant8_4) {
  const Model model = split_quant8_4::createTestModel();
  const std::vector<Request> requests = createRequests(split_quant8_4::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: squeeze_float16.mod.py.
namespace squeeze_float16 {
// Generated squeeze_float16 test
#include "examples/squeeze_float16.example.cpp"
// Generated model constructor
#include "vts_models/squeeze_float16.model.cpp"
} // namespace squeeze_float16

TEST_F(NeuralnetworksHidlTest, squeeze_float16) {
  generated_tests::Execute(device,
                           squeeze_float16::createTestModel,
                           squeeze_float16::is_ignored,
                           squeeze_float16::get_examples());
}

TEST_F(ValidationTest, squeeze_float16) {
  const Model model = squeeze_float16::createTestModel();
  const std::vector<Request> requests = createRequests(squeeze_float16::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: strided_slice_float16.mod.py.
namespace strided_slice_float16 {
// Generated strided_slice_float16 test
#include "examples/strided_slice_float16.example.cpp"
// Generated model constructor
#include "vts_models/strided_slice_float16.model.cpp"
} // namespace strided_slice_float16

TEST_F(NeuralnetworksHidlTest, strided_slice_float16) {
  generated_tests::Execute(device,
                           strided_slice_float16::createTestModel,
                           strided_slice_float16::is_ignored,
                           strided_slice_float16::get_examples());
}

TEST_F(ValidationTest, strided_slice_float16) {
  const Model model = strided_slice_float16::createTestModel();
  const std::vector<Request> requests = createRequests(strided_slice_float16::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: sub_float16.mod.py.
namespace sub_float16 {
// Generated sub_float16 test
#include "examples/sub_float16.example.cpp"
// Generated model constructor
#include "vts_models/sub_float16.model.cpp"
} // namespace sub_float16

TEST_F(NeuralnetworksHidlTest, sub_float16) {
  generated_tests::Execute(device,
                           sub_float16::createTestModel,
                           sub_float16::is_ignored,
                           sub_float16::get_examples());
}

TEST_F(ValidationTest, sub_float16) {
  const Model model = sub_float16::createTestModel();
  const std::vector<Request> requests = createRequests(sub_float16::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: sub_float16_broadcast.mod.py.
namespace sub_float16_broadcast {
// Generated sub_float16_broadcast test
#include "examples/sub_float16_broadcast.example.cpp"
// Generated model constructor
#include "vts_models/sub_float16_broadcast.model.cpp"
} // namespace sub_float16_broadcast

TEST_F(NeuralnetworksHidlTest, sub_float16_broadcast) {
  generated_tests::Execute(device,
                           sub_float16_broadcast::createTestModel,
                           sub_float16_broadcast::is_ignored,
                           sub_float16_broadcast::get_examples());
}

TEST_F(ValidationTest, sub_float16_broadcast) {
  const Model model = sub_float16_broadcast::createTestModel();
  const std::vector<Request> requests = createRequests(sub_float16_broadcast::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: sub_quantized.mod.py.
namespace sub_quantized {
// Generated sub_quantized test
#include "examples/sub_quantized.example.cpp"
// Generated model constructor
#include "vts_models/sub_quantized.model.cpp"
} // namespace sub_quantized

TEST_F(NeuralnetworksHidlTest, sub_quantized) {
  generated_tests::Execute(device,
                           sub_quantized::createTestModel,
                           sub_quantized::is_ignored,
                           sub_quantized::get_examples());
}

TEST_F(ValidationTest, sub_quantized) {
  const Model model = sub_quantized::createTestModel();
  const std::vector<Request> requests = createRequests(sub_quantized::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: sub_quantized_broadcast.mod.py.
namespace sub_quantized_broadcast {
// Generated sub_quantized_broadcast test
#include "examples/sub_quantized_broadcast.example.cpp"
// Generated model constructor
#include "vts_models/sub_quantized_broadcast.model.cpp"
} // namespace sub_quantized_broadcast

TEST_F(NeuralnetworksHidlTest, sub_quantized_broadcast) {
  generated_tests::Execute(device,
                           sub_quantized_broadcast::createTestModel,
                           sub_quantized_broadcast::is_ignored,
                           sub_quantized_broadcast::get_examples());
}

TEST_F(ValidationTest, sub_quantized_broadcast) {
  const Model model = sub_quantized_broadcast::createTestModel();
  const std::vector<Request> requests = createRequests(sub_quantized_broadcast::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: sub_quantized_different_scales.mod.py.
namespace sub_quantized_different_scales {
// Generated sub_quantized_different_scales test
#include "examples/sub_quantized_different_scales.example.cpp"
// Generated model constructor
#include "vts_models/sub_quantized_different_scales.model.cpp"
} // namespace sub_quantized_different_scales

TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel,
                           sub_quantized_different_scales::is_ignored,
                           sub_quantized_different_scales::get_examples());
}

TEST_F(ValidationTest, sub_quantized_different_scales) {
  const Model model = sub_quantized_different_scales::createTestModel();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_2) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_2,
                           sub_quantized_different_scales::is_ignored_2,
                           sub_quantized_different_scales::get_examples_2());
}

TEST_F(ValidationTest, sub_quantized_different_scales_2) {
  const Model model = sub_quantized_different_scales::createTestModel_2();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_3) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_3,
                           sub_quantized_different_scales::is_ignored_3,
                           sub_quantized_different_scales::get_examples_3());
}

TEST_F(ValidationTest, sub_quantized_different_scales_3) {
  const Model model = sub_quantized_different_scales::createTestModel_3();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_4) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_4,
                           sub_quantized_different_scales::is_ignored_4,
                           sub_quantized_different_scales::get_examples_4());
}

TEST_F(ValidationTest, sub_quantized_different_scales_4) {
  const Model model = sub_quantized_different_scales::createTestModel_4();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_5) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_5,
                           sub_quantized_different_scales::is_ignored_5,
                           sub_quantized_different_scales::get_examples_5());
}

TEST_F(ValidationTest, sub_quantized_different_scales_5) {
  const Model model = sub_quantized_different_scales::createTestModel_5();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_5());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_6) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_6,
                           sub_quantized_different_scales::is_ignored_6,
                           sub_quantized_different_scales::get_examples_6());
}

TEST_F(ValidationTest, sub_quantized_different_scales_6) {
  const Model model = sub_quantized_different_scales::createTestModel_6();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_6());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_7) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_7,
                           sub_quantized_different_scales::is_ignored_7,
                           sub_quantized_different_scales::get_examples_7());
}

TEST_F(ValidationTest, sub_quantized_different_scales_7) {
  const Model model = sub_quantized_different_scales::createTestModel_7();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_7());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_8) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_8,
                           sub_quantized_different_scales::is_ignored_8,
                           sub_quantized_different_scales::get_examples_8());
}

TEST_F(ValidationTest, sub_quantized_different_scales_8) {
  const Model model = sub_quantized_different_scales::createTestModel_8();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_9) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_9,
                           sub_quantized_different_scales::is_ignored_9,
                           sub_quantized_different_scales::get_examples_9());
}

TEST_F(ValidationTest, sub_quantized_different_scales_9) {
  const Model model = sub_quantized_different_scales::createTestModel_9();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_9());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_10) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_10,
                           sub_quantized_different_scales::is_ignored_10,
                           sub_quantized_different_scales::get_examples_10());
}

TEST_F(ValidationTest, sub_quantized_different_scales_10) {
  const Model model = sub_quantized_different_scales::createTestModel_10();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_10());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_11) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_11,
                           sub_quantized_different_scales::is_ignored_11,
                           sub_quantized_different_scales::get_examples_11());
}

TEST_F(ValidationTest, sub_quantized_different_scales_11) {
  const Model model = sub_quantized_different_scales::createTestModel_11();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_11());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_12) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_12,
                           sub_quantized_different_scales::is_ignored_12,
                           sub_quantized_different_scales::get_examples_12());
}

TEST_F(ValidationTest, sub_quantized_different_scales_12) {
  const Model model = sub_quantized_different_scales::createTestModel_12();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_12());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_13) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_13,
                           sub_quantized_different_scales::is_ignored_13,
                           sub_quantized_different_scales::get_examples_13());
}

TEST_F(ValidationTest, sub_quantized_different_scales_13) {
  const Model model = sub_quantized_different_scales::createTestModel_13();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_13());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_14) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_14,
                           sub_quantized_different_scales::is_ignored_14,
                           sub_quantized_different_scales::get_examples_14());
}

TEST_F(ValidationTest, sub_quantized_different_scales_14) {
  const Model model = sub_quantized_different_scales::createTestModel_14();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_14());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_15) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_15,
                           sub_quantized_different_scales::is_ignored_15,
                           sub_quantized_different_scales::get_examples_15());
}

TEST_F(ValidationTest, sub_quantized_different_scales_15) {
  const Model model = sub_quantized_different_scales::createTestModel_15();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_15());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_16) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_16,
                           sub_quantized_different_scales::is_ignored_16,
                           sub_quantized_different_scales::get_examples_16());
}

TEST_F(ValidationTest, sub_quantized_different_scales_16) {
  const Model model = sub_quantized_different_scales::createTestModel_16();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_17) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_17,
                           sub_quantized_different_scales::is_ignored_17,
                           sub_quantized_different_scales::get_examples_17());
}

TEST_F(ValidationTest, sub_quantized_different_scales_17) {
  const Model model = sub_quantized_different_scales::createTestModel_17();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_17());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_18) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_18,
                           sub_quantized_different_scales::is_ignored_18,
                           sub_quantized_different_scales::get_examples_18());
}

TEST_F(ValidationTest, sub_quantized_different_scales_18) {
  const Model model = sub_quantized_different_scales::createTestModel_18();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_18());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_19) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_19,
                           sub_quantized_different_scales::is_ignored_19,
                           sub_quantized_different_scales::get_examples_19());
}

TEST_F(ValidationTest, sub_quantized_different_scales_19) {
  const Model model = sub_quantized_different_scales::createTestModel_19();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_19());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_20) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_20,
                           sub_quantized_different_scales::is_ignored_20,
                           sub_quantized_different_scales::get_examples_20());
}

TEST_F(ValidationTest, sub_quantized_different_scales_20) {
  const Model model = sub_quantized_different_scales::createTestModel_20();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_20());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_21) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_21,
                           sub_quantized_different_scales::is_ignored_21,
                           sub_quantized_different_scales::get_examples_21());
}

TEST_F(ValidationTest, sub_quantized_different_scales_21) {
  const Model model = sub_quantized_different_scales::createTestModel_21();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_21());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_22) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_22,
                           sub_quantized_different_scales::is_ignored_22,
                           sub_quantized_different_scales::get_examples_22());
}

TEST_F(ValidationTest, sub_quantized_different_scales_22) {
  const Model model = sub_quantized_different_scales::createTestModel_22();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_22());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_23) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_23,
                           sub_quantized_different_scales::is_ignored_23,
                           sub_quantized_different_scales::get_examples_23());
}

TEST_F(ValidationTest, sub_quantized_different_scales_23) {
  const Model model = sub_quantized_different_scales::createTestModel_23();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_23());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_24) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_24,
                           sub_quantized_different_scales::is_ignored_24,
                           sub_quantized_different_scales::get_examples_24());
}

TEST_F(ValidationTest, sub_quantized_different_scales_24) {
  const Model model = sub_quantized_different_scales::createTestModel_24();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_24());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_25) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_25,
                           sub_quantized_different_scales::is_ignored_25,
                           sub_quantized_different_scales::get_examples_25());
}

TEST_F(ValidationTest, sub_quantized_different_scales_25) {
  const Model model = sub_quantized_different_scales::createTestModel_25();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_25());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_26) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_26,
                           sub_quantized_different_scales::is_ignored_26,
                           sub_quantized_different_scales::get_examples_26());
}

TEST_F(ValidationTest, sub_quantized_different_scales_26) {
  const Model model = sub_quantized_different_scales::createTestModel_26();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_26());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_27) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_27,
                           sub_quantized_different_scales::is_ignored_27,
                           sub_quantized_different_scales::get_examples_27());
}

TEST_F(ValidationTest, sub_quantized_different_scales_27) {
  const Model model = sub_quantized_different_scales::createTestModel_27();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_27());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_28) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_28,
                           sub_quantized_different_scales::is_ignored_28,
                           sub_quantized_different_scales::get_examples_28());
}

TEST_F(ValidationTest, sub_quantized_different_scales_28) {
  const Model model = sub_quantized_different_scales::createTestModel_28();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_28());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_29) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_29,
                           sub_quantized_different_scales::is_ignored_29,
                           sub_quantized_different_scales::get_examples_29());
}

TEST_F(ValidationTest, sub_quantized_different_scales_29) {
  const Model model = sub_quantized_different_scales::createTestModel_29();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_29());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_30) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_30,
                           sub_quantized_different_scales::is_ignored_30,
                           sub_quantized_different_scales::get_examples_30());
}

TEST_F(ValidationTest, sub_quantized_different_scales_30) {
  const Model model = sub_quantized_different_scales::createTestModel_30();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_30());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_31) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_31,
                           sub_quantized_different_scales::is_ignored_31,
                           sub_quantized_different_scales::get_examples_31());
}

TEST_F(ValidationTest, sub_quantized_different_scales_31) {
  const Model model = sub_quantized_different_scales::createTestModel_31();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_31());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_32) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_32,
                           sub_quantized_different_scales::is_ignored_32,
                           sub_quantized_different_scales::get_examples_32());
}

TEST_F(ValidationTest, sub_quantized_different_scales_32) {
  const Model model = sub_quantized_different_scales::createTestModel_32();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_32());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_33) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_33,
                           sub_quantized_different_scales::is_ignored_33,
                           sub_quantized_different_scales::get_examples_33());
}

TEST_F(ValidationTest, sub_quantized_different_scales_33) {
  const Model model = sub_quantized_different_scales::createTestModel_33();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_33());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_34) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_34,
                           sub_quantized_different_scales::is_ignored_34,
                           sub_quantized_different_scales::get_examples_34());
}

TEST_F(ValidationTest, sub_quantized_different_scales_34) {
  const Model model = sub_quantized_different_scales::createTestModel_34();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_34());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_35) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_35,
                           sub_quantized_different_scales::is_ignored_35,
                           sub_quantized_different_scales::get_examples_35());
}

TEST_F(ValidationTest, sub_quantized_different_scales_35) {
  const Model model = sub_quantized_different_scales::createTestModel_35();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_35());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_36) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_36,
                           sub_quantized_different_scales::is_ignored_36,
                           sub_quantized_different_scales::get_examples_36());
}

TEST_F(ValidationTest, sub_quantized_different_scales_36) {
  const Model model = sub_quantized_different_scales::createTestModel_36();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_36());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_37) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_37,
                           sub_quantized_different_scales::is_ignored_37,
                           sub_quantized_different_scales::get_examples_37());
}

TEST_F(ValidationTest, sub_quantized_different_scales_37) {
  const Model model = sub_quantized_different_scales::createTestModel_37();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_37());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_38) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_38,
                           sub_quantized_different_scales::is_ignored_38,
                           sub_quantized_different_scales::get_examples_38());
}

TEST_F(ValidationTest, sub_quantized_different_scales_38) {
  const Model model = sub_quantized_different_scales::createTestModel_38();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_38());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_39) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_39,
                           sub_quantized_different_scales::is_ignored_39,
                           sub_quantized_different_scales::get_examples_39());
}

TEST_F(ValidationTest, sub_quantized_different_scales_39) {
  const Model model = sub_quantized_different_scales::createTestModel_39();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_39());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_40) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_40,
                           sub_quantized_different_scales::is_ignored_40,
                           sub_quantized_different_scales::get_examples_40());
}

TEST_F(ValidationTest, sub_quantized_different_scales_40) {
  const Model model = sub_quantized_different_scales::createTestModel_40();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_40());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_41) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_41,
                           sub_quantized_different_scales::is_ignored_41,
                           sub_quantized_different_scales::get_examples_41());
}

TEST_F(ValidationTest, sub_quantized_different_scales_41) {
  const Model model = sub_quantized_different_scales::createTestModel_41();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_41());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_42) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_42,
                           sub_quantized_different_scales::is_ignored_42,
                           sub_quantized_different_scales::get_examples_42());
}

TEST_F(ValidationTest, sub_quantized_different_scales_42) {
  const Model model = sub_quantized_different_scales::createTestModel_42();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_42());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_43) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_43,
                           sub_quantized_different_scales::is_ignored_43,
                           sub_quantized_different_scales::get_examples_43());
}

TEST_F(ValidationTest, sub_quantized_different_scales_43) {
  const Model model = sub_quantized_different_scales::createTestModel_43();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_43());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_44) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_44,
                           sub_quantized_different_scales::is_ignored_44,
                           sub_quantized_different_scales::get_examples_44());
}

TEST_F(ValidationTest, sub_quantized_different_scales_44) {
  const Model model = sub_quantized_different_scales::createTestModel_44();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_44());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_45) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_45,
                           sub_quantized_different_scales::is_ignored_45,
                           sub_quantized_different_scales::get_examples_45());
}

TEST_F(ValidationTest, sub_quantized_different_scales_45) {
  const Model model = sub_quantized_different_scales::createTestModel_45();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_45());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_46) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_46,
                           sub_quantized_different_scales::is_ignored_46,
                           sub_quantized_different_scales::get_examples_46());
}

TEST_F(ValidationTest, sub_quantized_different_scales_46) {
  const Model model = sub_quantized_different_scales::createTestModel_46();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_46());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_47) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_47,
                           sub_quantized_different_scales::is_ignored_47,
                           sub_quantized_different_scales::get_examples_47());
}

TEST_F(ValidationTest, sub_quantized_different_scales_47) {
  const Model model = sub_quantized_different_scales::createTestModel_47();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_47());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_48) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_48,
                           sub_quantized_different_scales::is_ignored_48,
                           sub_quantized_different_scales::get_examples_48());
}

TEST_F(ValidationTest, sub_quantized_different_scales_48) {
  const Model model = sub_quantized_different_scales::createTestModel_48();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_48());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_49) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_49,
                           sub_quantized_different_scales::is_ignored_49,
                           sub_quantized_different_scales::get_examples_49());
}

TEST_F(ValidationTest, sub_quantized_different_scales_49) {
  const Model model = sub_quantized_different_scales::createTestModel_49();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_49());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_50) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_50,
                           sub_quantized_different_scales::is_ignored_50,
                           sub_quantized_different_scales::get_examples_50());
}

TEST_F(ValidationTest, sub_quantized_different_scales_50) {
  const Model model = sub_quantized_different_scales::createTestModel_50();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_50());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_51) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_51,
                           sub_quantized_different_scales::is_ignored_51,
                           sub_quantized_different_scales::get_examples_51());
}

TEST_F(ValidationTest, sub_quantized_different_scales_51) {
  const Model model = sub_quantized_different_scales::createTestModel_51();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_51());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_52) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_52,
                           sub_quantized_different_scales::is_ignored_52,
                           sub_quantized_different_scales::get_examples_52());
}

TEST_F(ValidationTest, sub_quantized_different_scales_52) {
  const Model model = sub_quantized_different_scales::createTestModel_52();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_52());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_53) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_53,
                           sub_quantized_different_scales::is_ignored_53,
                           sub_quantized_different_scales::get_examples_53());
}

TEST_F(ValidationTest, sub_quantized_different_scales_53) {
  const Model model = sub_quantized_different_scales::createTestModel_53();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_53());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_54) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_54,
                           sub_quantized_different_scales::is_ignored_54,
                           sub_quantized_different_scales::get_examples_54());
}

TEST_F(ValidationTest, sub_quantized_different_scales_54) {
  const Model model = sub_quantized_different_scales::createTestModel_54();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_54());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_55) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_55,
                           sub_quantized_different_scales::is_ignored_55,
                           sub_quantized_different_scales::get_examples_55());
}

TEST_F(ValidationTest, sub_quantized_different_scales_55) {
  const Model model = sub_quantized_different_scales::createTestModel_55();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_55());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_56) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_56,
                           sub_quantized_different_scales::is_ignored_56,
                           sub_quantized_different_scales::get_examples_56());
}

TEST_F(ValidationTest, sub_quantized_different_scales_56) {
  const Model model = sub_quantized_different_scales::createTestModel_56();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_56());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_57) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_57,
                           sub_quantized_different_scales::is_ignored_57,
                           sub_quantized_different_scales::get_examples_57());
}

TEST_F(ValidationTest, sub_quantized_different_scales_57) {
  const Model model = sub_quantized_different_scales::createTestModel_57();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_57());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_58) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_58,
                           sub_quantized_different_scales::is_ignored_58,
                           sub_quantized_different_scales::get_examples_58());
}

TEST_F(ValidationTest, sub_quantized_different_scales_58) {
  const Model model = sub_quantized_different_scales::createTestModel_58();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_58());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_59) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_59,
                           sub_quantized_different_scales::is_ignored_59,
                           sub_quantized_different_scales::get_examples_59());
}

TEST_F(ValidationTest, sub_quantized_different_scales_59) {
  const Model model = sub_quantized_different_scales::createTestModel_59();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_59());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_60) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_60,
                           sub_quantized_different_scales::is_ignored_60,
                           sub_quantized_different_scales::get_examples_60());
}

TEST_F(ValidationTest, sub_quantized_different_scales_60) {
  const Model model = sub_quantized_different_scales::createTestModel_60();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_60());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_61) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_61,
                           sub_quantized_different_scales::is_ignored_61,
                           sub_quantized_different_scales::get_examples_61());
}

TEST_F(ValidationTest, sub_quantized_different_scales_61) {
  const Model model = sub_quantized_different_scales::createTestModel_61();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_61());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_62) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_62,
                           sub_quantized_different_scales::is_ignored_62,
                           sub_quantized_different_scales::get_examples_62());
}

TEST_F(ValidationTest, sub_quantized_different_scales_62) {
  const Model model = sub_quantized_different_scales::createTestModel_62();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_62());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_63) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_63,
                           sub_quantized_different_scales::is_ignored_63,
                           sub_quantized_different_scales::get_examples_63());
}

TEST_F(ValidationTest, sub_quantized_different_scales_63) {
  const Model model = sub_quantized_different_scales::createTestModel_63();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_63());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, sub_quantized_different_scales_64) {
  generated_tests::Execute(device,
                           sub_quantized_different_scales::createTestModel_64,
                           sub_quantized_different_scales::is_ignored_64,
                           sub_quantized_different_scales::get_examples_64());
}

TEST_F(ValidationTest, sub_quantized_different_scales_64) {
  const Model model = sub_quantized_different_scales::createTestModel_64();
  const std::vector<Request> requests = createRequests(sub_quantized_different_scales::get_examples_64());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: tanh_float16.mod.py.
namespace tanh_float16 {
// Generated tanh_float16 test
#include "examples/tanh_float16.example.cpp"
// Generated model constructor
#include "vts_models/tanh_float16.model.cpp"
} // namespace tanh_float16

TEST_F(NeuralnetworksHidlTest, tanh_float16) {
  generated_tests::Execute(device,
                           tanh_float16::createTestModel,
                           tanh_float16::is_ignored,
                           tanh_float16::get_examples());
}

TEST_F(ValidationTest, tanh_float16) {
  const Model model = tanh_float16::createTestModel();
  const std::vector<Request> requests = createRequests(tanh_float16::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: tanh_quantized.mod.py.
namespace tanh_quantized {
// Generated tanh_quantized test
#include "examples/tanh_quantized.example.cpp"
// Generated model constructor
#include "vts_models/tanh_quantized.model.cpp"
} // namespace tanh_quantized

TEST_F(NeuralnetworksHidlTest, tanh_quantized) {
  generated_tests::Execute(device,
                           tanh_quantized::createTestModel,
                           tanh_quantized::is_ignored,
                           tanh_quantized::get_examples());
}

TEST_F(ValidationTest, tanh_quantized) {
  const Model model = tanh_quantized::createTestModel();
  const std::vector<Request> requests = createRequests(tanh_quantized::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: tile_1.mod.py.
namespace tile_1 {
// Generated tile_1 test
#include "examples/tile_1.example.cpp"
// Generated model constructor
#include "vts_models/tile_1.model.cpp"
} // namespace tile_1

TEST_F(NeuralnetworksHidlTest, tile_1) {
  generated_tests::Execute(device,
                           tile_1::createTestModel,
                           tile_1::is_ignored,
                           tile_1::get_examples());
}

TEST_F(ValidationTest, tile_1) {
  const Model model = tile_1::createTestModel();
  const std::vector<Request> requests = createRequests(tile_1::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, tile_1_relaxed) {
  generated_tests::Execute(device,
                           tile_1::createTestModel_relaxed,
                           tile_1::is_ignored_relaxed,
                           tile_1::get_examples_relaxed());
}

TEST_F(ValidationTest, tile_1_relaxed) {
  const Model model = tile_1::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(tile_1::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, tile_1_float16) {
  generated_tests::Execute(device,
                           tile_1::createTestModel_float16,
                           tile_1::is_ignored_float16,
                           tile_1::get_examples_float16());
}

TEST_F(ValidationTest, tile_1_float16) {
  const Model model = tile_1::createTestModel_float16();
  const std::vector<Request> requests = createRequests(tile_1::get_examples_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, tile_1_quant8) {
  generated_tests::Execute(device,
                           tile_1::createTestModel_quant8,
                           tile_1::is_ignored_quant8,
                           tile_1::get_examples_quant8());
}

TEST_F(ValidationTest, tile_1_quant8) {
  const Model model = tile_1::createTestModel_quant8();
  const std::vector<Request> requests = createRequests(tile_1::get_examples_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: tile_2.mod.py.
namespace tile_2 {
// Generated tile_2 test
#include "examples/tile_2.example.cpp"
// Generated model constructor
#include "vts_models/tile_2.model.cpp"
} // namespace tile_2

TEST_F(NeuralnetworksHidlTest, tile_2) {
  generated_tests::Execute(device,
                           tile_2::createTestModel,
                           tile_2::is_ignored,
                           tile_2::get_examples());
}

TEST_F(ValidationTest, tile_2) {
  const Model model = tile_2::createTestModel();
  const std::vector<Request> requests = createRequests(tile_2::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, tile_2_relaxed) {
  generated_tests::Execute(device,
                           tile_2::createTestModel_relaxed,
                           tile_2::is_ignored_relaxed,
                           tile_2::get_examples_relaxed());
}

TEST_F(ValidationTest, tile_2_relaxed) {
  const Model model = tile_2::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(tile_2::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, tile_2_float16) {
  generated_tests::Execute(device,
                           tile_2::createTestModel_float16,
                           tile_2::is_ignored_float16,
                           tile_2::get_examples_float16());
}

TEST_F(ValidationTest, tile_2_float16) {
  const Model model = tile_2::createTestModel_float16();
  const std::vector<Request> requests = createRequests(tile_2::get_examples_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, tile_2_quant8) {
  generated_tests::Execute(device,
                           tile_2::createTestModel_quant8,
                           tile_2::is_ignored_quant8,
                           tile_2::get_examples_quant8());
}

TEST_F(ValidationTest, tile_2_quant8) {
  const Model model = tile_2::createTestModel_quant8();
  const std::vector<Request> requests = createRequests(tile_2::get_examples_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, tile_2_int32) {
  generated_tests::Execute(device,
                           tile_2::createTestModel_int32,
                           tile_2::is_ignored_int32,
                           tile_2::get_examples_int32());
}

TEST_F(ValidationTest, tile_2_int32) {
  const Model model = tile_2::createTestModel_int32();
  const std::vector<Request> requests = createRequests(tile_2::get_examples_int32());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: tile_3.mod.py.
namespace tile_3 {
// Generated tile_3 test
#include "examples/tile_3.example.cpp"
// Generated model constructor
#include "vts_models/tile_3.model.cpp"
} // namespace tile_3

TEST_F(NeuralnetworksHidlTest, tile_3) {
  generated_tests::Execute(device,
                           tile_3::createTestModel,
                           tile_3::is_ignored,
                           tile_3::get_examples());
}

TEST_F(ValidationTest, tile_3) {
  const Model model = tile_3::createTestModel();
  const std::vector<Request> requests = createRequests(tile_3::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, tile_3_relaxed) {
  generated_tests::Execute(device,
                           tile_3::createTestModel_relaxed,
                           tile_3::is_ignored_relaxed,
                           tile_3::get_examples_relaxed());
}

TEST_F(ValidationTest, tile_3_relaxed) {
  const Model model = tile_3::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(tile_3::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, tile_3_float16) {
  generated_tests::Execute(device,
                           tile_3::createTestModel_float16,
                           tile_3::is_ignored_float16,
                           tile_3::get_examples_float16());
}

TEST_F(ValidationTest, tile_3_float16) {
  const Model model = tile_3::createTestModel_float16();
  const std::vector<Request> requests = createRequests(tile_3::get_examples_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, tile_3_quant8) {
  generated_tests::Execute(device,
                           tile_3::createTestModel_quant8,
                           tile_3::is_ignored_quant8,
                           tile_3::get_examples_quant8());
}

TEST_F(ValidationTest, tile_3_quant8) {
  const Model model = tile_3::createTestModel_quant8();
  const std::vector<Request> requests = createRequests(tile_3::get_examples_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, tile_3_int32) {
  generated_tests::Execute(device,
                           tile_3::createTestModel_int32,
                           tile_3::is_ignored_int32,
                           tile_3::get_examples_int32());
}

TEST_F(ValidationTest, tile_3_int32) {
  const Model model = tile_3::createTestModel_int32();
  const std::vector<Request> requests = createRequests(tile_3::get_examples_int32());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: topk_v2.mod.py.
namespace topk_v2 {
// Generated topk_v2 test
#include "examples/topk_v2.example.cpp"
// Generated model constructor
#include "vts_models/topk_v2.model.cpp"
} // namespace topk_v2

TEST_F(NeuralnetworksHidlTest, topk_v2) {
  generated_tests::Execute(device,
                           topk_v2::createTestModel,
                           topk_v2::is_ignored,
                           topk_v2::get_examples());
}

TEST_F(ValidationTest, topk_v2) {
  const Model model = topk_v2::createTestModel();
  const std::vector<Request> requests = createRequests(topk_v2::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, topk_v2_relaxed) {
  generated_tests::Execute(device,
                           topk_v2::createTestModel_relaxed,
                           topk_v2::is_ignored_relaxed,
                           topk_v2::get_examples_relaxed());
}

TEST_F(ValidationTest, topk_v2_relaxed) {
  const Model model = topk_v2::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(topk_v2::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, topk_v2_float16) {
  generated_tests::Execute(device,
                           topk_v2::createTestModel_float16,
                           topk_v2::is_ignored_float16,
                           topk_v2::get_examples_float16());
}

TEST_F(ValidationTest, topk_v2_float16) {
  const Model model = topk_v2::createTestModel_float16();
  const std::vector<Request> requests = createRequests(topk_v2::get_examples_float16());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, topk_v2_2) {
  generated_tests::Execute(device,
                           topk_v2::createTestModel_2,
                           topk_v2::is_ignored_2,
                           topk_v2::get_examples_2());
}

TEST_F(ValidationTest, topk_v2_2) {
  const Model model = topk_v2::createTestModel_2();
  const std::vector<Request> requests = createRequests(topk_v2::get_examples_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, topk_v2_relaxed_2) {
  generated_tests::Execute(device,
                           topk_v2::createTestModel_relaxed_2,
                           topk_v2::is_ignored_relaxed_2,
                           topk_v2::get_examples_relaxed_2());
}

TEST_F(ValidationTest, topk_v2_relaxed_2) {
  const Model model = topk_v2::createTestModel_relaxed_2();
  const std::vector<Request> requests = createRequests(topk_v2::get_examples_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, topk_v2_float16_2) {
  generated_tests::Execute(device,
                           topk_v2::createTestModel_float16_2,
                           topk_v2::is_ignored_float16_2,
                           topk_v2::get_examples_float16_2());
}

TEST_F(ValidationTest, topk_v2_float16_2) {
  const Model model = topk_v2::createTestModel_float16_2();
  const std::vector<Request> requests = createRequests(topk_v2::get_examples_float16_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, topk_v2_3) {
  generated_tests::Execute(device,
                           topk_v2::createTestModel_3,
                           topk_v2::is_ignored_3,
                           topk_v2::get_examples_3());
}

TEST_F(ValidationTest, topk_v2_3) {
  const Model model = topk_v2::createTestModel_3();
  const std::vector<Request> requests = createRequests(topk_v2::get_examples_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, topk_v2_relaxed_3) {
  generated_tests::Execute(device,
                           topk_v2::createTestModel_relaxed_3,
                           topk_v2::is_ignored_relaxed_3,
                           topk_v2::get_examples_relaxed_3());
}

TEST_F(ValidationTest, topk_v2_relaxed_3) {
  const Model model = topk_v2::createTestModel_relaxed_3();
  const std::vector<Request> requests = createRequests(topk_v2::get_examples_relaxed_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, topk_v2_float16_3) {
  generated_tests::Execute(device,
                           topk_v2::createTestModel_float16_3,
                           topk_v2::is_ignored_float16_3,
                           topk_v2::get_examples_float16_3());
}

TEST_F(ValidationTest, topk_v2_float16_3) {
  const Model model = topk_v2::createTestModel_float16_3();
  const std::vector<Request> requests = createRequests(topk_v2::get_examples_float16_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, topk_v2_4) {
  generated_tests::Execute(device,
                           topk_v2::createTestModel_4,
                           topk_v2::is_ignored_4,
                           topk_v2::get_examples_4());
}

TEST_F(ValidationTest, topk_v2_4) {
  const Model model = topk_v2::createTestModel_4();
  const std::vector<Request> requests = createRequests(topk_v2::get_examples_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, topk_v2_relaxed_4) {
  generated_tests::Execute(device,
                           topk_v2::createTestModel_relaxed_4,
                           topk_v2::is_ignored_relaxed_4,
                           topk_v2::get_examples_relaxed_4());
}

TEST_F(ValidationTest, topk_v2_relaxed_4) {
  const Model model = topk_v2::createTestModel_relaxed_4();
  const std::vector<Request> requests = createRequests(topk_v2::get_examples_relaxed_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, topk_v2_float16_4) {
  generated_tests::Execute(device,
                           topk_v2::createTestModel_float16_4,
                           topk_v2::is_ignored_float16_4,
                           topk_v2::get_examples_float16_4());
}

TEST_F(ValidationTest, topk_v2_float16_4) {
  const Model model = topk_v2::createTestModel_float16_4();
  const std::vector<Request> requests = createRequests(topk_v2::get_examples_float16_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, topk_v2_5) {
  generated_tests::Execute(device,
                           topk_v2::createTestModel_5,
                           topk_v2::is_ignored_5,
                           topk_v2::get_examples_5());
}

TEST_F(ValidationTest, topk_v2_5) {
  const Model model = topk_v2::createTestModel_5();
  const std::vector<Request> requests = createRequests(topk_v2::get_examples_5());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, topk_v2_relaxed_5) {
  generated_tests::Execute(device,
                           topk_v2::createTestModel_relaxed_5,
                           topk_v2::is_ignored_relaxed_5,
                           topk_v2::get_examples_relaxed_5());
}

TEST_F(ValidationTest, topk_v2_relaxed_5) {
  const Model model = topk_v2::createTestModel_relaxed_5();
  const std::vector<Request> requests = createRequests(topk_v2::get_examples_relaxed_5());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, topk_v2_float16_5) {
  generated_tests::Execute(device,
                           topk_v2::createTestModel_float16_5,
                           topk_v2::is_ignored_float16_5,
                           topk_v2::get_examples_float16_5());
}

TEST_F(ValidationTest, topk_v2_float16_5) {
  const Model model = topk_v2::createTestModel_float16_5();
  const std::vector<Request> requests = createRequests(topk_v2::get_examples_float16_5());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, topk_v2_6) {
  generated_tests::Execute(device,
                           topk_v2::createTestModel_6,
                           topk_v2::is_ignored_6,
                           topk_v2::get_examples_6());
}

TEST_F(ValidationTest, topk_v2_6) {
  const Model model = topk_v2::createTestModel_6();
  const std::vector<Request> requests = createRequests(topk_v2::get_examples_6());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, topk_v2_relaxed_6) {
  generated_tests::Execute(device,
                           topk_v2::createTestModel_relaxed_6,
                           topk_v2::is_ignored_relaxed_6,
                           topk_v2::get_examples_relaxed_6());
}

TEST_F(ValidationTest, topk_v2_relaxed_6) {
  const Model model = topk_v2::createTestModel_relaxed_6();
  const std::vector<Request> requests = createRequests(topk_v2::get_examples_relaxed_6());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, topk_v2_float16_6) {
  generated_tests::Execute(device,
                           topk_v2::createTestModel_float16_6,
                           topk_v2::is_ignored_float16_6,
                           topk_v2::get_examples_float16_6());
}

TEST_F(ValidationTest, topk_v2_float16_6) {
  const Model model = topk_v2::createTestModel_float16_6();
  const std::vector<Request> requests = createRequests(topk_v2::get_examples_float16_6());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: transpose_conv2d.mod.py.
namespace transpose_conv2d {
// Generated transpose_conv2d test
#include "examples/transpose_conv2d.example.cpp"
// Generated model constructor
#include "vts_models/transpose_conv2d.model.cpp"
} // namespace transpose_conv2d

TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_none) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_none,
                           transpose_conv2d::is_ignored_nhwc_none,
                           transpose_conv2d::get_examples_nhwc_none());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_none) {
  const Model model = transpose_conv2d::createTestModel_nhwc_none();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_none());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_none_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_none_weight_as_input,
                           transpose_conv2d::is_ignored_nhwc_none_weight_as_input,
                           transpose_conv2d::get_examples_nhwc_none_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_none_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nhwc_none_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_none_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_none_relaxed) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_none_relaxed,
                           transpose_conv2d::is_ignored_nhwc_none_relaxed,
                           transpose_conv2d::get_examples_nhwc_none_relaxed());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_none_relaxed) {
  const Model model = transpose_conv2d::createTestModel_nhwc_none_relaxed();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_none_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_none_relaxed_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_none_relaxed_weight_as_input,
                           transpose_conv2d::is_ignored_nhwc_none_relaxed_weight_as_input,
                           transpose_conv2d::get_examples_nhwc_none_relaxed_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_none_relaxed_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nhwc_none_relaxed_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_none_relaxed_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_none_quant8) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_none_quant8,
                           transpose_conv2d::is_ignored_nhwc_none_quant8,
                           transpose_conv2d::get_examples_nhwc_none_quant8());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_none_quant8) {
  const Model model = transpose_conv2d::createTestModel_nhwc_none_quant8();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_none_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_none_quant8_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_none_quant8_weight_as_input,
                           transpose_conv2d::is_ignored_nhwc_none_quant8_weight_as_input,
                           transpose_conv2d::get_examples_nhwc_none_quant8_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_none_quant8_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nhwc_none_quant8_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_none_quant8_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relu) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relu,
                           transpose_conv2d::is_ignored_nhwc_relu,
                           transpose_conv2d::get_examples_nhwc_relu());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relu) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relu();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relu());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relu_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relu_weight_as_input,
                           transpose_conv2d::is_ignored_nhwc_relu_weight_as_input,
                           transpose_conv2d::get_examples_nhwc_relu_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relu_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relu_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relu_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relu_relaxed) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relu_relaxed,
                           transpose_conv2d::is_ignored_nhwc_relu_relaxed,
                           transpose_conv2d::get_examples_nhwc_relu_relaxed());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relu_relaxed) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relu_relaxed();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relu_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relu_relaxed_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relu_relaxed_weight_as_input,
                           transpose_conv2d::is_ignored_nhwc_relu_relaxed_weight_as_input,
                           transpose_conv2d::get_examples_nhwc_relu_relaxed_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relu_relaxed_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relu_relaxed_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relu_relaxed_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relu_quant8) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relu_quant8,
                           transpose_conv2d::is_ignored_nhwc_relu_quant8,
                           transpose_conv2d::get_examples_nhwc_relu_quant8());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relu_quant8) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relu_quant8();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relu_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relu_quant8_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relu_quant8_weight_as_input,
                           transpose_conv2d::is_ignored_nhwc_relu_quant8_weight_as_input,
                           transpose_conv2d::get_examples_nhwc_relu_quant8_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relu_quant8_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relu_quant8_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relu_quant8_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relu1) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relu1,
                           transpose_conv2d::is_ignored_nhwc_relu1,
                           transpose_conv2d::get_examples_nhwc_relu1());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relu1) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relu1();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relu1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relu1_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relu1_weight_as_input,
                           transpose_conv2d::is_ignored_nhwc_relu1_weight_as_input,
                           transpose_conv2d::get_examples_nhwc_relu1_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relu1_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relu1_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relu1_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relu1_relaxed) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relu1_relaxed,
                           transpose_conv2d::is_ignored_nhwc_relu1_relaxed,
                           transpose_conv2d::get_examples_nhwc_relu1_relaxed());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relu1_relaxed) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relu1_relaxed();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relu1_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relu1_relaxed_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relu1_relaxed_weight_as_input,
                           transpose_conv2d::is_ignored_nhwc_relu1_relaxed_weight_as_input,
                           transpose_conv2d::get_examples_nhwc_relu1_relaxed_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relu1_relaxed_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relu1_relaxed_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relu1_relaxed_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relu1_quant8) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relu1_quant8,
                           transpose_conv2d::is_ignored_nhwc_relu1_quant8,
                           transpose_conv2d::get_examples_nhwc_relu1_quant8());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relu1_quant8) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relu1_quant8();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relu1_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relu1_quant8_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relu1_quant8_weight_as_input,
                           transpose_conv2d::is_ignored_nhwc_relu1_quant8_weight_as_input,
                           transpose_conv2d::get_examples_nhwc_relu1_quant8_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relu1_quant8_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relu1_quant8_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relu1_quant8_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relu6) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relu6,
                           transpose_conv2d::is_ignored_nhwc_relu6,
                           transpose_conv2d::get_examples_nhwc_relu6());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relu6) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relu6();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relu6());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relu6_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relu6_weight_as_input,
                           transpose_conv2d::is_ignored_nhwc_relu6_weight_as_input,
                           transpose_conv2d::get_examples_nhwc_relu6_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relu6_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relu6_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relu6_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relu6_relaxed) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relu6_relaxed,
                           transpose_conv2d::is_ignored_nhwc_relu6_relaxed,
                           transpose_conv2d::get_examples_nhwc_relu6_relaxed());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relu6_relaxed) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relu6_relaxed();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relu6_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relu6_relaxed_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relu6_relaxed_weight_as_input,
                           transpose_conv2d::is_ignored_nhwc_relu6_relaxed_weight_as_input,
                           transpose_conv2d::get_examples_nhwc_relu6_relaxed_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relu6_relaxed_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relu6_relaxed_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relu6_relaxed_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relu6_quant8) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relu6_quant8,
                           transpose_conv2d::is_ignored_nhwc_relu6_quant8,
                           transpose_conv2d::get_examples_nhwc_relu6_quant8());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relu6_quant8) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relu6_quant8();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relu6_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relu6_quant8_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relu6_quant8_weight_as_input,
                           transpose_conv2d::is_ignored_nhwc_relu6_quant8_weight_as_input,
                           transpose_conv2d::get_examples_nhwc_relu6_quant8_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relu6_quant8_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relu6_quant8_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relu6_quant8_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_none) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_none,
                           transpose_conv2d::is_ignored_nchw_none,
                           transpose_conv2d::get_examples_nchw_none());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_none) {
  const Model model = transpose_conv2d::createTestModel_nchw_none();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_none());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_none_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_none_weight_as_input,
                           transpose_conv2d::is_ignored_nchw_none_weight_as_input,
                           transpose_conv2d::get_examples_nchw_none_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_none_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nchw_none_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_none_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_none_relaxed) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_none_relaxed,
                           transpose_conv2d::is_ignored_nchw_none_relaxed,
                           transpose_conv2d::get_examples_nchw_none_relaxed());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_none_relaxed) {
  const Model model = transpose_conv2d::createTestModel_nchw_none_relaxed();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_none_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_none_relaxed_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_none_relaxed_weight_as_input,
                           transpose_conv2d::is_ignored_nchw_none_relaxed_weight_as_input,
                           transpose_conv2d::get_examples_nchw_none_relaxed_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_none_relaxed_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nchw_none_relaxed_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_none_relaxed_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_none_quant8) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_none_quant8,
                           transpose_conv2d::is_ignored_nchw_none_quant8,
                           transpose_conv2d::get_examples_nchw_none_quant8());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_none_quant8) {
  const Model model = transpose_conv2d::createTestModel_nchw_none_quant8();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_none_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_none_quant8_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_none_quant8_weight_as_input,
                           transpose_conv2d::is_ignored_nchw_none_quant8_weight_as_input,
                           transpose_conv2d::get_examples_nchw_none_quant8_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_none_quant8_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nchw_none_quant8_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_none_quant8_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relu) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relu,
                           transpose_conv2d::is_ignored_nchw_relu,
                           transpose_conv2d::get_examples_nchw_relu());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relu) {
  const Model model = transpose_conv2d::createTestModel_nchw_relu();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relu());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relu_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relu_weight_as_input,
                           transpose_conv2d::is_ignored_nchw_relu_weight_as_input,
                           transpose_conv2d::get_examples_nchw_relu_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relu_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nchw_relu_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relu_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relu_relaxed) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relu_relaxed,
                           transpose_conv2d::is_ignored_nchw_relu_relaxed,
                           transpose_conv2d::get_examples_nchw_relu_relaxed());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relu_relaxed) {
  const Model model = transpose_conv2d::createTestModel_nchw_relu_relaxed();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relu_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relu_relaxed_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relu_relaxed_weight_as_input,
                           transpose_conv2d::is_ignored_nchw_relu_relaxed_weight_as_input,
                           transpose_conv2d::get_examples_nchw_relu_relaxed_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relu_relaxed_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nchw_relu_relaxed_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relu_relaxed_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relu_quant8) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relu_quant8,
                           transpose_conv2d::is_ignored_nchw_relu_quant8,
                           transpose_conv2d::get_examples_nchw_relu_quant8());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relu_quant8) {
  const Model model = transpose_conv2d::createTestModel_nchw_relu_quant8();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relu_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relu_quant8_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relu_quant8_weight_as_input,
                           transpose_conv2d::is_ignored_nchw_relu_quant8_weight_as_input,
                           transpose_conv2d::get_examples_nchw_relu_quant8_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relu_quant8_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nchw_relu_quant8_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relu_quant8_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relu1) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relu1,
                           transpose_conv2d::is_ignored_nchw_relu1,
                           transpose_conv2d::get_examples_nchw_relu1());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relu1) {
  const Model model = transpose_conv2d::createTestModel_nchw_relu1();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relu1());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relu1_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relu1_weight_as_input,
                           transpose_conv2d::is_ignored_nchw_relu1_weight_as_input,
                           transpose_conv2d::get_examples_nchw_relu1_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relu1_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nchw_relu1_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relu1_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relu1_relaxed) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relu1_relaxed,
                           transpose_conv2d::is_ignored_nchw_relu1_relaxed,
                           transpose_conv2d::get_examples_nchw_relu1_relaxed());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relu1_relaxed) {
  const Model model = transpose_conv2d::createTestModel_nchw_relu1_relaxed();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relu1_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relu1_relaxed_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relu1_relaxed_weight_as_input,
                           transpose_conv2d::is_ignored_nchw_relu1_relaxed_weight_as_input,
                           transpose_conv2d::get_examples_nchw_relu1_relaxed_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relu1_relaxed_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nchw_relu1_relaxed_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relu1_relaxed_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relu1_quant8) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relu1_quant8,
                           transpose_conv2d::is_ignored_nchw_relu1_quant8,
                           transpose_conv2d::get_examples_nchw_relu1_quant8());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relu1_quant8) {
  const Model model = transpose_conv2d::createTestModel_nchw_relu1_quant8();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relu1_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relu1_quant8_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relu1_quant8_weight_as_input,
                           transpose_conv2d::is_ignored_nchw_relu1_quant8_weight_as_input,
                           transpose_conv2d::get_examples_nchw_relu1_quant8_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relu1_quant8_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nchw_relu1_quant8_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relu1_quant8_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relu6) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relu6,
                           transpose_conv2d::is_ignored_nchw_relu6,
                           transpose_conv2d::get_examples_nchw_relu6());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relu6) {
  const Model model = transpose_conv2d::createTestModel_nchw_relu6();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relu6());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relu6_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relu6_weight_as_input,
                           transpose_conv2d::is_ignored_nchw_relu6_weight_as_input,
                           transpose_conv2d::get_examples_nchw_relu6_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relu6_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nchw_relu6_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relu6_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relu6_relaxed) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relu6_relaxed,
                           transpose_conv2d::is_ignored_nchw_relu6_relaxed,
                           transpose_conv2d::get_examples_nchw_relu6_relaxed());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relu6_relaxed) {
  const Model model = transpose_conv2d::createTestModel_nchw_relu6_relaxed();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relu6_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relu6_relaxed_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relu6_relaxed_weight_as_input,
                           transpose_conv2d::is_ignored_nchw_relu6_relaxed_weight_as_input,
                           transpose_conv2d::get_examples_nchw_relu6_relaxed_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relu6_relaxed_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nchw_relu6_relaxed_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relu6_relaxed_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relu6_quant8) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relu6_quant8,
                           transpose_conv2d::is_ignored_nchw_relu6_quant8,
                           transpose_conv2d::get_examples_nchw_relu6_quant8());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relu6_quant8) {
  const Model model = transpose_conv2d::createTestModel_nchw_relu6_quant8();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relu6_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relu6_quant8_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relu6_quant8_weight_as_input,
                           transpose_conv2d::is_ignored_nchw_relu6_quant8_weight_as_input,
                           transpose_conv2d::get_examples_nchw_relu6_quant8_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relu6_quant8_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nchw_relu6_quant8_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relu6_quant8_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc,
                           transpose_conv2d::is_ignored_nhwc,
                           transpose_conv2d::get_examples_nhwc());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc) {
  const Model model = transpose_conv2d::createTestModel_nhwc();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_weight_as_input,
                           transpose_conv2d::is_ignored_nhwc_weight_as_input,
                           transpose_conv2d::get_examples_nhwc_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nhwc_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relaxed) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relaxed,
                           transpose_conv2d::is_ignored_nhwc_relaxed,
                           transpose_conv2d::get_examples_nhwc_relaxed());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relaxed) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relaxed();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relaxed_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relaxed_weight_as_input,
                           transpose_conv2d::is_ignored_nhwc_relaxed_weight_as_input,
                           transpose_conv2d::get_examples_nhwc_relaxed_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relaxed_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relaxed_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relaxed_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_quant8) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_quant8,
                           transpose_conv2d::is_ignored_nhwc_quant8,
                           transpose_conv2d::get_examples_nhwc_quant8());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_quant8) {
  const Model model = transpose_conv2d::createTestModel_nhwc_quant8();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_quant8_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_quant8_weight_as_input,
                           transpose_conv2d::is_ignored_nhwc_quant8_weight_as_input,
                           transpose_conv2d::get_examples_nhwc_quant8_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_quant8_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nhwc_quant8_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_quant8_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw,
                           transpose_conv2d::is_ignored_nchw,
                           transpose_conv2d::get_examples_nchw());
}

TEST_F(ValidationTest, transpose_conv2d_nchw) {
  const Model model = transpose_conv2d::createTestModel_nchw();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_weight_as_input,
                           transpose_conv2d::is_ignored_nchw_weight_as_input,
                           transpose_conv2d::get_examples_nchw_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nchw_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relaxed) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relaxed,
                           transpose_conv2d::is_ignored_nchw_relaxed,
                           transpose_conv2d::get_examples_nchw_relaxed());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relaxed) {
  const Model model = transpose_conv2d::createTestModel_nchw_relaxed();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relaxed_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relaxed_weight_as_input,
                           transpose_conv2d::is_ignored_nchw_relaxed_weight_as_input,
                           transpose_conv2d::get_examples_nchw_relaxed_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relaxed_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nchw_relaxed_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relaxed_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_quant8) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_quant8,
                           transpose_conv2d::is_ignored_nchw_quant8,
                           transpose_conv2d::get_examples_nchw_quant8());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_quant8) {
  const Model model = transpose_conv2d::createTestModel_nchw_quant8();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_quant8());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_quant8_weight_as_input) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_quant8_weight_as_input,
                           transpose_conv2d::is_ignored_nchw_quant8_weight_as_input,
                           transpose_conv2d::get_examples_nchw_quant8_weight_as_input());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_quant8_weight_as_input) {
  const Model model = transpose_conv2d::createTestModel_nchw_quant8_weight_as_input();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_quant8_weight_as_input());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_2) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_2,
                           transpose_conv2d::is_ignored_nhwc_2,
                           transpose_conv2d::get_examples_nhwc_2());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_2) {
  const Model model = transpose_conv2d::createTestModel_nhwc_2();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_weight_as_input_2) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_weight_as_input_2,
                           transpose_conv2d::is_ignored_nhwc_weight_as_input_2,
                           transpose_conv2d::get_examples_nhwc_weight_as_input_2());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_weight_as_input_2) {
  const Model model = transpose_conv2d::createTestModel_nhwc_weight_as_input_2();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_weight_as_input_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relaxed_2) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relaxed_2,
                           transpose_conv2d::is_ignored_nhwc_relaxed_2,
                           transpose_conv2d::get_examples_nhwc_relaxed_2());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relaxed_2) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relaxed_2();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relaxed_weight_as_input_2) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relaxed_weight_as_input_2,
                           transpose_conv2d::is_ignored_nhwc_relaxed_weight_as_input_2,
                           transpose_conv2d::get_examples_nhwc_relaxed_weight_as_input_2());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relaxed_weight_as_input_2) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relaxed_weight_as_input_2();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relaxed_weight_as_input_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_quant8_2) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_quant8_2,
                           transpose_conv2d::is_ignored_nhwc_quant8_2,
                           transpose_conv2d::get_examples_nhwc_quant8_2());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_quant8_2) {
  const Model model = transpose_conv2d::createTestModel_nhwc_quant8_2();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_quant8_weight_as_input_2) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_quant8_weight_as_input_2,
                           transpose_conv2d::is_ignored_nhwc_quant8_weight_as_input_2,
                           transpose_conv2d::get_examples_nhwc_quant8_weight_as_input_2());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_quant8_weight_as_input_2) {
  const Model model = transpose_conv2d::createTestModel_nhwc_quant8_weight_as_input_2();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_quant8_weight_as_input_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_2) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_2,
                           transpose_conv2d::is_ignored_nchw_2,
                           transpose_conv2d::get_examples_nchw_2());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_2) {
  const Model model = transpose_conv2d::createTestModel_nchw_2();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_weight_as_input_2) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_weight_as_input_2,
                           transpose_conv2d::is_ignored_nchw_weight_as_input_2,
                           transpose_conv2d::get_examples_nchw_weight_as_input_2());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_weight_as_input_2) {
  const Model model = transpose_conv2d::createTestModel_nchw_weight_as_input_2();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_weight_as_input_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relaxed_2) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relaxed_2,
                           transpose_conv2d::is_ignored_nchw_relaxed_2,
                           transpose_conv2d::get_examples_nchw_relaxed_2());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relaxed_2) {
  const Model model = transpose_conv2d::createTestModel_nchw_relaxed_2();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relaxed_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relaxed_weight_as_input_2) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relaxed_weight_as_input_2,
                           transpose_conv2d::is_ignored_nchw_relaxed_weight_as_input_2,
                           transpose_conv2d::get_examples_nchw_relaxed_weight_as_input_2());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relaxed_weight_as_input_2) {
  const Model model = transpose_conv2d::createTestModel_nchw_relaxed_weight_as_input_2();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relaxed_weight_as_input_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_quant8_2) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_quant8_2,
                           transpose_conv2d::is_ignored_nchw_quant8_2,
                           transpose_conv2d::get_examples_nchw_quant8_2());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_quant8_2) {
  const Model model = transpose_conv2d::createTestModel_nchw_quant8_2();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_quant8_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_quant8_weight_as_input_2) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_quant8_weight_as_input_2,
                           transpose_conv2d::is_ignored_nchw_quant8_weight_as_input_2,
                           transpose_conv2d::get_examples_nchw_quant8_weight_as_input_2());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_quant8_weight_as_input_2) {
  const Model model = transpose_conv2d::createTestModel_nchw_quant8_weight_as_input_2();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_quant8_weight_as_input_2());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_3) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_3,
                           transpose_conv2d::is_ignored_nhwc_3,
                           transpose_conv2d::get_examples_nhwc_3());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_3) {
  const Model model = transpose_conv2d::createTestModel_nhwc_3();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_weight_as_input_3) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_weight_as_input_3,
                           transpose_conv2d::is_ignored_nhwc_weight_as_input_3,
                           transpose_conv2d::get_examples_nhwc_weight_as_input_3());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_weight_as_input_3) {
  const Model model = transpose_conv2d::createTestModel_nhwc_weight_as_input_3();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_weight_as_input_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relaxed_3) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relaxed_3,
                           transpose_conv2d::is_ignored_nhwc_relaxed_3,
                           transpose_conv2d::get_examples_nhwc_relaxed_3());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relaxed_3) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relaxed_3();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relaxed_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relaxed_weight_as_input_3) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relaxed_weight_as_input_3,
                           transpose_conv2d::is_ignored_nhwc_relaxed_weight_as_input_3,
                           transpose_conv2d::get_examples_nhwc_relaxed_weight_as_input_3());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relaxed_weight_as_input_3) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relaxed_weight_as_input_3();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relaxed_weight_as_input_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_quant8_3) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_quant8_3,
                           transpose_conv2d::is_ignored_nhwc_quant8_3,
                           transpose_conv2d::get_examples_nhwc_quant8_3());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_quant8_3) {
  const Model model = transpose_conv2d::createTestModel_nhwc_quant8_3();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_quant8_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_quant8_weight_as_input_3) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_quant8_weight_as_input_3,
                           transpose_conv2d::is_ignored_nhwc_quant8_weight_as_input_3,
                           transpose_conv2d::get_examples_nhwc_quant8_weight_as_input_3());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_quant8_weight_as_input_3) {
  const Model model = transpose_conv2d::createTestModel_nhwc_quant8_weight_as_input_3();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_quant8_weight_as_input_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_3) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_3,
                           transpose_conv2d::is_ignored_nchw_3,
                           transpose_conv2d::get_examples_nchw_3());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_3) {
  const Model model = transpose_conv2d::createTestModel_nchw_3();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_weight_as_input_3) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_weight_as_input_3,
                           transpose_conv2d::is_ignored_nchw_weight_as_input_3,
                           transpose_conv2d::get_examples_nchw_weight_as_input_3());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_weight_as_input_3) {
  const Model model = transpose_conv2d::createTestModel_nchw_weight_as_input_3();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_weight_as_input_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relaxed_3) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relaxed_3,
                           transpose_conv2d::is_ignored_nchw_relaxed_3,
                           transpose_conv2d::get_examples_nchw_relaxed_3());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relaxed_3) {
  const Model model = transpose_conv2d::createTestModel_nchw_relaxed_3();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relaxed_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relaxed_weight_as_input_3) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relaxed_weight_as_input_3,
                           transpose_conv2d::is_ignored_nchw_relaxed_weight_as_input_3,
                           transpose_conv2d::get_examples_nchw_relaxed_weight_as_input_3());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relaxed_weight_as_input_3) {
  const Model model = transpose_conv2d::createTestModel_nchw_relaxed_weight_as_input_3();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relaxed_weight_as_input_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_quant8_3) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_quant8_3,
                           transpose_conv2d::is_ignored_nchw_quant8_3,
                           transpose_conv2d::get_examples_nchw_quant8_3());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_quant8_3) {
  const Model model = transpose_conv2d::createTestModel_nchw_quant8_3();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_quant8_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_quant8_weight_as_input_3) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_quant8_weight_as_input_3,
                           transpose_conv2d::is_ignored_nchw_quant8_weight_as_input_3,
                           transpose_conv2d::get_examples_nchw_quant8_weight_as_input_3());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_quant8_weight_as_input_3) {
  const Model model = transpose_conv2d::createTestModel_nchw_quant8_weight_as_input_3();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_quant8_weight_as_input_3());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_4) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_4,
                           transpose_conv2d::is_ignored_nhwc_4,
                           transpose_conv2d::get_examples_nhwc_4());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_4) {
  const Model model = transpose_conv2d::createTestModel_nhwc_4();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_weight_as_input_4) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_weight_as_input_4,
                           transpose_conv2d::is_ignored_nhwc_weight_as_input_4,
                           transpose_conv2d::get_examples_nhwc_weight_as_input_4());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_weight_as_input_4) {
  const Model model = transpose_conv2d::createTestModel_nhwc_weight_as_input_4();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_weight_as_input_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relaxed_4) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relaxed_4,
                           transpose_conv2d::is_ignored_nhwc_relaxed_4,
                           transpose_conv2d::get_examples_nhwc_relaxed_4());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relaxed_4) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relaxed_4();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relaxed_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_relaxed_weight_as_input_4) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_relaxed_weight_as_input_4,
                           transpose_conv2d::is_ignored_nhwc_relaxed_weight_as_input_4,
                           transpose_conv2d::get_examples_nhwc_relaxed_weight_as_input_4());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_relaxed_weight_as_input_4) {
  const Model model = transpose_conv2d::createTestModel_nhwc_relaxed_weight_as_input_4();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_relaxed_weight_as_input_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_quant8_4) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_quant8_4,
                           transpose_conv2d::is_ignored_nhwc_quant8_4,
                           transpose_conv2d::get_examples_nhwc_quant8_4());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_quant8_4) {
  const Model model = transpose_conv2d::createTestModel_nhwc_quant8_4();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_quant8_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nhwc_quant8_weight_as_input_4) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nhwc_quant8_weight_as_input_4,
                           transpose_conv2d::is_ignored_nhwc_quant8_weight_as_input_4,
                           transpose_conv2d::get_examples_nhwc_quant8_weight_as_input_4());
}

TEST_F(ValidationTest, transpose_conv2d_nhwc_quant8_weight_as_input_4) {
  const Model model = transpose_conv2d::createTestModel_nhwc_quant8_weight_as_input_4();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nhwc_quant8_weight_as_input_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_4) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_4,
                           transpose_conv2d::is_ignored_nchw_4,
                           transpose_conv2d::get_examples_nchw_4());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_4) {
  const Model model = transpose_conv2d::createTestModel_nchw_4();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_weight_as_input_4) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_weight_as_input_4,
                           transpose_conv2d::is_ignored_nchw_weight_as_input_4,
                           transpose_conv2d::get_examples_nchw_weight_as_input_4());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_weight_as_input_4) {
  const Model model = transpose_conv2d::createTestModel_nchw_weight_as_input_4();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_weight_as_input_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relaxed_4) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relaxed_4,
                           transpose_conv2d::is_ignored_nchw_relaxed_4,
                           transpose_conv2d::get_examples_nchw_relaxed_4());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relaxed_4) {
  const Model model = transpose_conv2d::createTestModel_nchw_relaxed_4();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relaxed_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_relaxed_weight_as_input_4) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_relaxed_weight_as_input_4,
                           transpose_conv2d::is_ignored_nchw_relaxed_weight_as_input_4,
                           transpose_conv2d::get_examples_nchw_relaxed_weight_as_input_4());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_relaxed_weight_as_input_4) {
  const Model model = transpose_conv2d::createTestModel_nchw_relaxed_weight_as_input_4();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_relaxed_weight_as_input_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_quant8_4) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_quant8_4,
                           transpose_conv2d::is_ignored_nchw_quant8_4,
                           transpose_conv2d::get_examples_nchw_quant8_4());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_quant8_4) {
  const Model model = transpose_conv2d::createTestModel_nchw_quant8_4();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_quant8_4());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_conv2d_nchw_quant8_weight_as_input_4) {
  generated_tests::Execute(device,
                           transpose_conv2d::createTestModel_nchw_quant8_weight_as_input_4,
                           transpose_conv2d::is_ignored_nchw_quant8_weight_as_input_4,
                           transpose_conv2d::get_examples_nchw_quant8_weight_as_input_4());
}

TEST_F(ValidationTest, transpose_conv2d_nchw_quant8_weight_as_input_4) {
  const Model model = transpose_conv2d::createTestModel_nchw_quant8_weight_as_input_4();
  const std::vector<Request> requests = createRequests(transpose_conv2d::get_examples_nchw_quant8_weight_as_input_4());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: transpose_float16.mod.py.
namespace transpose_float16 {
// Generated transpose_float16 test
#include "examples/transpose_float16.example.cpp"
// Generated model constructor
#include "vts_models/transpose_float16.model.cpp"
} // namespace transpose_float16

TEST_F(NeuralnetworksHidlTest, transpose_float16) {
  generated_tests::Execute(device,
                           transpose_float16::createTestModel,
                           transpose_float16::is_ignored,
                           transpose_float16::get_examples());
}

TEST_F(ValidationTest, transpose_float16) {
  const Model model = transpose_float16::createTestModel();
  const std::vector<Request> requests = createRequests(transpose_float16::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


// Generated from: transpose_v1_2.mod.py.
namespace transpose_v1_2 {
// Generated transpose_v1_2 test
#include "examples/transpose_v1_2.example.cpp"
// Generated model constructor
#include "vts_models/transpose_v1_2.model.cpp"
} // namespace transpose_v1_2

TEST_F(NeuralnetworksHidlTest, transpose_v1_2) {
  generated_tests::Execute(device,
                           transpose_v1_2::createTestModel,
                           transpose_v1_2::is_ignored,
                           transpose_v1_2::get_examples());
}

TEST_F(ValidationTest, transpose_v1_2) {
  const Model model = transpose_v1_2::createTestModel();
  const std::vector<Request> requests = createRequests(transpose_v1_2::get_examples());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_v1_2_relaxed) {
  generated_tests::Execute(device,
                           transpose_v1_2::createTestModel_relaxed,
                           transpose_v1_2::is_ignored_relaxed,
                           transpose_v1_2::get_examples_relaxed());
}

TEST_F(ValidationTest, transpose_v1_2_relaxed) {
  const Model model = transpose_v1_2::createTestModel_relaxed();
  const std::vector<Request> requests = createRequests(transpose_v1_2::get_examples_relaxed());
  validateModel(model);
  validateRequests(model, requests);
}


TEST_F(NeuralnetworksHidlTest, transpose_v1_2_quant8) {
  generated_tests::Execute(device,
                           transpose_v1_2::createTestModel_quant8,
                           transpose_v1_2::is_ignored_quant8,
                           transpose_v1_2::get_examples_quant8());
}

TEST_F(ValidationTest, transpose_v1_2_quant8) {
  const Model model = transpose_v1_2::createTestModel_quant8();
  const std::vector<Request> requests = createRequests(transpose_v1_2::get_examples_quant8());
  validateModel(model);
  validateRequests(model, requests);
}