text: // Generated from densify_1.mod.py
  // DO NOT EDIT
  // clang-format off
  #include "TestHarness.h"
  using namespace test_helper;  // NOLINT(google-build-using-namespace)
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }},
                  .operations = {{
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {0},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model = TestModelManager::get().add("densify_1", get_test_model());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_all_inputs_as_internal() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }, { // sparseData_new
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }, { // placeholder
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {1},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({0.0f})
                          }, { // param
                              .type = TestOperandType::INT32,
                              .dimensions = {},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0})
                          }},
                  .operations = {{
                              .type = TestOperationType::ADD,
                              .inputs = {10, 11, 12},
                              .outputs = {0}
                          }, {
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {10},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_all_inputs_as_internal = TestModelManager::get().add("densify_1_all_inputs_as_internal", get_test_model_all_inputs_as_internal());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_all_tensors_as_inputs() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }},
                  .operations = {{
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_all_tensors_as_inputs = TestModelManager::get().add("densify_1_all_tensors_as_inputs", get_test_model_all_tensors_as_inputs());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_all_tensors_as_inputs_all_inputs_as_internal() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }, { // sparseData_new
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }, { // placeholder1
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {1},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({0.0f})
                          }, { // param1
                              .type = TestOperandType::INT32,
                              .dimensions = {},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0})
                          }},
                  .operations = {{
                              .type = TestOperationType::ADD,
                              .inputs = {10, 11, 12},
                              .outputs = {0}
                          }, {
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {1, 2, 3, 4, 5, 6, 7, 8, 10},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_all_tensors_as_inputs_all_inputs_as_internal = TestModelManager::get().add("densify_1_all_tensors_as_inputs_all_inputs_as_internal", get_test_model_all_tensors_as_inputs_all_inputs_as_internal());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_relaxed() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }},
                  .operations = {{
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {0},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = true,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_relaxed = TestModelManager::get().add("densify_1_relaxed", get_test_model_relaxed());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_relaxed_all_inputs_as_internal() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }, { // sparseData_new
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }, { // placeholder2
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {1},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({0.0f})
                          }, { // param2
                              .type = TestOperandType::INT32,
                              .dimensions = {},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0})
                          }},
                  .operations = {{
                              .type = TestOperationType::ADD,
                              .inputs = {10, 11, 12},
                              .outputs = {0}
                          }, {
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {10},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = true,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_relaxed_all_inputs_as_internal = TestModelManager::get().add("densify_1_relaxed_all_inputs_as_internal", get_test_model_relaxed_all_inputs_as_internal());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_relaxed_all_tensors_as_inputs() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }},
                  .operations = {{
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = true,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_relaxed_all_tensors_as_inputs = TestModelManager::get().add("densify_1_relaxed_all_tensors_as_inputs", get_test_model_relaxed_all_tensors_as_inputs());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_relaxed_all_tensors_as_inputs_all_inputs_as_internal() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }, { // sparseData_new
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }, { // placeholder3
                              .type = TestOperandType::TENSOR_FLOAT32,
                              .dimensions = {1},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<float>({0.0f})
                          }, { // param3
                              .type = TestOperandType::INT32,
                              .dimensions = {},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0})
                          }},
                  .operations = {{
                              .type = TestOperationType::ADD,
                              .inputs = {10, 11, 12},
                              .outputs = {0}
                          }, {
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {1, 2, 3, 4, 5, 6, 7, 8, 10},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = true,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_relaxed_all_tensors_as_inputs_all_inputs_as_internal = TestModelManager::get().add("densify_1_relaxed_all_tensors_as_inputs_all_inputs_as_internal", get_test_model_relaxed_all_tensors_as_inputs_all_inputs_as_internal());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_float16() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_FLOAT16,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<_Float16>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_FLOAT16,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<_Float16>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }},
                  .operations = {{
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {0},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_float16 = TestModelManager::get().add("densify_1_float16", get_test_model_float16());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_float16_all_inputs_as_internal() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_FLOAT16,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<_Float16>({})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_FLOAT16,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<_Float16>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }, { // sparseData_new
                              .type = TestOperandType::TENSOR_FLOAT16,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<_Float16>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }, { // placeholder4
                              .type = TestOperandType::TENSOR_FLOAT16,
                              .dimensions = {1},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<_Float16>({0.0f})
                          }, { // param4
                              .type = TestOperandType::INT32,
                              .dimensions = {},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0})
                          }},
                  .operations = {{
                              .type = TestOperationType::ADD,
                              .inputs = {10, 11, 12},
                              .outputs = {0}
                          }, {
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {10},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_float16_all_inputs_as_internal = TestModelManager::get().add("densify_1_float16_all_inputs_as_internal", get_test_model_float16_all_inputs_as_internal());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_float16_all_tensors_as_inputs() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_FLOAT16,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<_Float16>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_FLOAT16,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<_Float16>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }},
                  .operations = {{
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_float16_all_tensors_as_inputs = TestModelManager::get().add("densify_1_float16_all_tensors_as_inputs", get_test_model_float16_all_tensors_as_inputs());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_float16_all_tensors_as_inputs_all_inputs_as_internal() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_FLOAT16,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<_Float16>({})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_FLOAT16,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<_Float16>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }, { // sparseData_new
                              .type = TestOperandType::TENSOR_FLOAT16,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<_Float16>({6.0f, 0.0f, 9.0f, 8.0f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 7.0f})
                          }, { // placeholder5
                              .type = TestOperandType::TENSOR_FLOAT16,
                              .dimensions = {1},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<_Float16>({0.0f})
                          }, { // param5
                              .type = TestOperandType::INT32,
                              .dimensions = {},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0})
                          }},
                  .operations = {{
                              .type = TestOperationType::ADD,
                              .inputs = {10, 11, 12},
                              .outputs = {0}
                          }, {
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {1, 2, 3, 4, 5, 6, 7, 8, 10},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_float16_all_tensors_as_inputs_all_inputs_as_internal = TestModelManager::get().add("densify_1_float16_all_tensors_as_inputs_all_inputs_as_internal", get_test_model_float16_all_tensors_as_inputs_all_inputs_as_internal());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_int32() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({6, 0, 9, 8, 0, 0, 0, 0, 5, 0, 0, 7})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({6, 0, 9, 8, 0, 0, 0, 0, 5, 0, 0, 7})
                          }},
                  .operations = {{
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {0},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_int32 = TestModelManager::get().add("densify_1_int32", get_test_model_int32());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_int32_all_tensors_as_inputs() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({6, 0, 9, 8, 0, 0, 0, 0, 5, 0, 0, 7})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({6, 0, 9, 8, 0, 0, 0, 0, 5, 0, 0, 7})
                          }},
                  .operations = {{
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_int32_all_tensors_as_inputs = TestModelManager::get().add("densify_1_int32_all_tensors_as_inputs", get_test_model_int32_all_tensors_as_inputs());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_float32() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_QUANT8_SYMM,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 2.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int8_t>({3, 0, 4, 4, 0, 0, 0, 0, 2, 0, 0, 4})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_QUANT8_SYMM,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 2.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int8_t>({3, 0, 4, 4, 0, 0, 0, 0, 2, 0, 0, 4})
                          }},
                  .operations = {{
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {0},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_float32 = TestModelManager::get().add("densify_1_float32", get_test_model_float32());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_float32_all_tensors_as_inputs() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_QUANT8_SYMM,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 2.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int8_t>({3, 0, 4, 4, 0, 0, 0, 0, 2, 0, 0, 4})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_QUANT8_SYMM,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 2.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int8_t>({3, 0, 4, 4, 0, 0, 0, 0, 2, 0, 0, 4})
                          }},
                  .operations = {{
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_float32_all_tensors_as_inputs = TestModelManager::get().add("densify_1_float32_all_tensors_as_inputs", get_test_model_float32_all_tensors_as_inputs());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_quant8() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .zeroPoint = 4,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<uint8_t>({16, 4, 22, 20, 4, 4, 4, 4, 14, 4, 4, 18})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .zeroPoint = 4,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<uint8_t>({16, 4, 22, 20, 4, 4, 4, 4, 14, 4, 4, 18})
                          }},
                  .operations = {{
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {0},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_quant8 = TestModelManager::get().add("densify_1_quant8", get_test_model_quant8());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_quant8_all_inputs_as_internal() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .zeroPoint = 4,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<uint8_t>({})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .zeroPoint = 4,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<uint8_t>({16, 4, 22, 20, 4, 4, 4, 4, 14, 4, 4, 18})
                          }, { // sparseData_new
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .zeroPoint = 4,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<uint8_t>({16, 4, 22, 20, 4, 4, 4, 4, 14, 4, 4, 18})
                          }, { // placeholder6
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                              .dimensions = {1},
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .zeroPoint = 4,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<uint8_t>({4})
                          }, { // param6
                              .type = TestOperandType::INT32,
                              .dimensions = {},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0})
                          }},
                  .operations = {{
                              .type = TestOperationType::ADD,
                              .inputs = {10, 11, 12},
                              .outputs = {0}
                          }, {
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {10},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_quant8_all_inputs_as_internal = TestModelManager::get().add("densify_1_quant8_all_inputs_as_internal", get_test_model_quant8_all_inputs_as_internal());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_quant8_all_tensors_as_inputs() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .zeroPoint = 4,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<uint8_t>({16, 4, 22, 20, 4, 4, 4, 4, 14, 4, 4, 18})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .zeroPoint = 4,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<uint8_t>({16, 4, 22, 20, 4, 4, 4, 4, 14, 4, 4, 18})
                          }},
                  .operations = {{
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_quant8_all_tensors_as_inputs = TestModelManager::get().add("densify_1_quant8_all_tensors_as_inputs", get_test_model_quant8_all_tensors_as_inputs());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_quant8_all_tensors_as_inputs_all_inputs_as_internal() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .zeroPoint = 4,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<uint8_t>({})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 0.5f,
                              .zeroPoint = 4,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<uint8_t>({16, 4, 22, 20, 4, 4, 4, 4, 14, 4, 4, 18})
                          }, { // sparseData_new
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .zeroPoint = 4,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<uint8_t>({16, 4, 22, 20, 4, 4, 4, 4, 14, 4, 4, 18})
                          }, { // placeholder7
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM,
                              .dimensions = {1},
                              .numberOfConsumers = 1,
                              .scale = 0.5f,
                              .zeroPoint = 4,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<uint8_t>({4})
                          }, { // param7
                              .type = TestOperandType::INT32,
                              .dimensions = {},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0})
                          }},
                  .operations = {{
                              .type = TestOperationType::ADD,
                              .inputs = {10, 11, 12},
                              .outputs = {0}
                          }, {
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {1, 2, 3, 4, 5, 6, 7, 8, 10},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_quant8_all_tensors_as_inputs_all_inputs_as_internal = TestModelManager::get().add("densify_1_quant8_all_tensors_as_inputs_all_inputs_as_internal", get_test_model_quant8_all_tensors_as_inputs_all_inputs_as_internal());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_quant8_signed() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 2.5f,
                              .zeroPoint = -9,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int8_t>({-7, -9, -5, -6, -9, -9, -9, -9, -7, -9, -9, -6})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 2.5f,
                              .zeroPoint = -9,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int8_t>({-7, -9, -5, -6, -9, -9, -9, -9, -7, -9, -9, -6})
                          }},
                  .operations = {{
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {0},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_quant8_signed = TestModelManager::get().add("densify_1_quant8_signed", get_test_model_quant8_signed());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_quant8_signed_all_inputs_as_internal() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 2.5f,
                              .zeroPoint = -9,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int8_t>({})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 2.5f,
                              .zeroPoint = -9,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int8_t>({-7, -9, -5, -6, -9, -9, -9, -9, -7, -9, -9, -6})
                          }, { // sparseData_new
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 2.5f,
                              .zeroPoint = -9,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int8_t>({-7, -9, -5, -6, -9, -9, -9, -9, -7, -9, -9, -6})
                          }, { // placeholder8
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .dimensions = {1},
                              .numberOfConsumers = 1,
                              .scale = 2.5f,
                              .zeroPoint = -9,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int8_t>({-9})
                          }, { // param8
                              .type = TestOperandType::INT32,
                              .dimensions = {},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0})
                          }},
                  .operations = {{
                              .type = TestOperationType::ADD,
                              .inputs = {10, 11, 12},
                              .outputs = {0}
                          }, {
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {10},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_quant8_signed_all_inputs_as_internal = TestModelManager::get().add("densify_1_quant8_signed_all_inputs_as_internal", get_test_model_quant8_signed_all_inputs_as_internal());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_quant8_signed_all_tensors_as_inputs() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 2.5f,
                              .zeroPoint = -9,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int8_t>({-7, -9, -5, -6, -9, -9, -9, -9, -7, -9, -9, -6})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 2.5f,
                              .zeroPoint = -9,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int8_t>({-7, -9, -5, -6, -9, -9, -9, -9, -7, -9, -9, -6})
                          }},
                  .operations = {{
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_quant8_signed_all_tensors_as_inputs = TestModelManager::get().add("densify_1_quant8_signed_all_tensors_as_inputs", get_test_model_quant8_signed_all_tensors_as_inputs());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 2.5f,
                              .zeroPoint = -9,
                              .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int8_t>({})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 2.5f,
                              .zeroPoint = -9,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int8_t>({-7, -9, -5, -6, -9, -9, -9, -9, -7, -9, -9, -6})
                          }, { // sparseData_new
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 2.5f,
                              .zeroPoint = -9,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int8_t>({-7, -9, -5, -6, -9, -9, -9, -9, -7, -9, -9, -6})
                          }, { // placeholder9
                              .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
                              .dimensions = {1},
                              .numberOfConsumers = 1,
                              .scale = 2.5f,
                              .zeroPoint = -9,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int8_t>({-9})
                          }, { // param9
                              .type = TestOperandType::INT32,
                              .dimensions = {},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0})
                          }},
                  .operations = {{
                              .type = TestOperationType::ADD,
                              .inputs = {10, 11, 12},
                              .outputs = {0}
                          }, {
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {1, 2, 3, 4, 5, 6, 7, 8, 10},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal = TestModelManager::get().add("densify_1_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal", get_test_model_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_float32_2() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_QUANT16_SYMM,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 3.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int16_t>({2, 0, 3, 3, 0, 0, 0, 0, 2, 0, 0, 2})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_QUANT16_SYMM,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 3.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int16_t>({2, 0, 3, 3, 0, 0, 0, 0, 2, 0, 0, 2})
                          }},
                  .operations = {{
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {0},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_float32_2 = TestModelManager::get().add("densify_1_float32_2", get_test_model_float32_2());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_float32_all_tensors_as_inputs_2() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_QUANT16_SYMM,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 3.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int16_t>({2, 0, 3, 3, 0, 0, 0, 0, 2, 0, 0, 2})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_QUANT16_SYMM,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 3.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int16_t>({2, 0, 3, 3, 0, 0, 0, 0, 2, 0, 0, 2})
                          }},
                  .operations = {{
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_float32_all_tensors_as_inputs_2 = TestModelManager::get().add("densify_1_float32_all_tensors_as_inputs_2", get_test_model_float32_all_tensors_as_inputs_2());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_float32_3() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_QUANT16_ASYMM,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 2.0f,
                              .zeroPoint = 4,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<uint16_t>({7, 4, 8, 8, 4, 4, 4, 4, 6, 4, 4, 8})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::CONSTANT_COPY,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_QUANT16_ASYMM,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 2.0f,
                              .zeroPoint = 4,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<uint16_t>({7, 4, 8, 8, 4, 4, 4, 4, 6, 4, 4, 8})
                          }},
                  .operations = {{
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {0},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_float32_3 = TestModelManager::get().add("densify_1_float32_3", get_test_model_float32_3());
  
  }  // namespace generated_tests::densify_1
  
  namespace generated_tests::densify_1 {
  
  const TestModel& get_test_model_float32_all_tensors_as_inputs_3() {
      static TestModel model = {
          .main = {
                  .operands = {{ // sparseData
                              .type = TestOperandType::TENSOR_QUANT16_ASYMM,
                              .dimensions = {12},
                              .numberOfConsumers = 1,
                              .scale = 2.0f,
                              .zeroPoint = 4,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<uint16_t>({7, 4, 8, 8, 4, 4, 4, 4, 6, 4, 4, 8})
                          }, { // traversalOrder
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 1})
                          }, { // blockMap
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // dimFormat
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({0, 0})
                          }, { // dimensions
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {2},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({3, 4})
                          }, { // d0ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d0ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrSegments
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // d1ArrIndices
                              .type = TestOperandType::TENSOR_INT32,
                              .dimensions = {0},
                              .numberOfConsumers = 1,
                              .scale = 0.0f,
                              .zeroPoint = 0,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<int32_t>({})
                          }, { // denseOut
                              .type = TestOperandType::TENSOR_QUANT16_ASYMM,
                              .dimensions = {3, 4},
                              .numberOfConsumers = 0,
                              .scale = 2.0f,
                              .zeroPoint = 4,
                              .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
                              .channelQuant = {},
                              .isIgnored = false,
                              .data = TestBuffer::createFromVector<uint16_t>({7, 4, 8, 8, 4, 4, 4, 4, 6, 4, 4, 8})
                          }},
                  .operations = {{
                              .type = TestOperationType::DENSIFY,
                              .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                              .outputs = {9}
                          }},
                  .inputIndexes = {0, 1, 2, 3, 4, 5, 6, 7, 8},
                  .outputIndexes = {9}
              },
          .referenced = {},
          .isRelaxed = false,
          .expectedMultinomialDistributionTolerance = 0,
          .expectFailure = false,
          .minSupportedVersion = TestHalVersion::UNKNOWN
      };
      return model;
  }
  
  const auto dummy_test_model_float32_all_tensors_as_inputs_3 = TestModelManager::get().add("densify_1_float32_all_tensors_as_inputs_3", get_test_model_float32_all_tensors_as_inputs_3());
  
  }  // namespace generated_tests::densify_1
  
  