Google Git
Sign in
android / platform / packages / modules / NeuralNetworks / 0cfe20796 / . / runtime / test / generated / spec_AIDL_V2 / batch_matmul.example.cpp
blob: cb01958f0924f2a6d6b112c6648b119958a46e92 [file] [log] [blame]
// Generated from batch_matmul.mod.py
// DO NOT EDIT
// clang-format off
#include "TestHarness.h"
using namespace test_helper;
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_Simple() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 1},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}),
.dimensions = {1, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op2
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f}),
.dimensions = {1, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // adj0
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj1
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op3
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({74.0f, 80.0f, 86.0f, 92.0f, 173.0f, 188.0f, 203.0f, 218.0f}),
.dimensions = {1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_Simple = TestModelManager::get().add("batch_matmul_Simple", get_test_model_Simple());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_Simple_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {5, 8},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({}),
.dimensions = {1, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op2
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({}),
.dimensions = {1, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // adj0
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj1
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op3
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({74.0f, 80.0f, 86.0f, 92.0f, 173.0f, 188.0f, 203.0f, 218.0f}),
.dimensions = {1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op1_new
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}),
.dimensions = {1, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // placeholder
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}, { // op2_new
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f}),
.dimensions = {1, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // placeholder1
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {8, 9, 10},
.outputs = {1},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_Simple_all_inputs_as_internal = TestModelManager::get().add("batch_matmul_Simple_all_inputs_as_internal", get_test_model_Simple_all_inputs_as_internal());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_Simple_float16() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 1},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}),
.dimensions = {1, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // op2
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f}),
.dimensions = {1, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // adj0
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj1
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op3
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({74.0f, 80.0f, 86.0f, 92.0f, 173.0f, 188.0f, 203.0f, 218.0f}),
.dimensions = {1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_Simple_float16 = TestModelManager::get().add("batch_matmul_Simple_float16", get_test_model_Simple_float16());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_Simple_float16_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {5, 8},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({}),
.dimensions = {1, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // op2
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({}),
.dimensions = {1, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // adj0
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj1
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op3
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({74.0f, 80.0f, 86.0f, 92.0f, 173.0f, 188.0f, 203.0f, 218.0f}),
.dimensions = {1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // op1_new
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}),
.dimensions = {1, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // placeholder2
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}, { // op2_new
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f}),
.dimensions = {1, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // placeholder3
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // param3
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {8, 9, 10},
.outputs = {1},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_Simple_float16_all_inputs_as_internal = TestModelManager::get().add("batch_matmul_Simple_float16_all_inputs_as_internal", get_test_model_Simple_float16_all_inputs_as_internal());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_Simple_int32() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 1},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 2, 3, 4, 5, 6}),
.dimensions = {1, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // op2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}),
.dimensions = {1, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // adj0
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj1
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op3
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({74, 80, 86, 92, 173, 188, 203, 218}),
.dimensions = {1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_Simple_int32 = TestModelManager::get().add("batch_matmul_Simple_int32", get_test_model_Simple_int32());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_Simple_quant8_signed() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 1},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({4, 8, 12, 16, 20, 24}),
.dimensions = {1, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // op2
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-50, -48, -46, -44, -42, -40, -38, -36, -34, -32, -30, -28}),
.dimensions = {1, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -64
}, { // adj0
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj1
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op3
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-54, -48, -42, -36, 45, 60, 75, 90}),
.dimensions = {1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_Simple_quant8_signed = TestModelManager::get().add("batch_matmul_Simple_quant8_signed", get_test_model_Simple_quant8_signed());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_Simple_quant8_signed_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {5, 8},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // op2
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -64
}, { // adj0
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj1
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op3
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-54, -48, -42, -36, 45, 60, 75, 90}),
.dimensions = {1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // op1_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({4, 8, 12, 16, 20, 24}),
.dimensions = {1, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // placeholder4
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param4
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}, { // op2_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-50, -48, -46, -44, -42, -40, -38, -36, -34, -32, -30, -28}),
.dimensions = {1, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -64
}, { // placeholder5
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-64}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -64
}, { // param5
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {8, 9, 10},
.outputs = {1},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_Simple_quant8_signed_all_inputs_as_internal = TestModelManager::get().add("batch_matmul_Simple_quant8_signed_all_inputs_as_internal", get_test_model_Simple_quant8_signed_all_inputs_as_internal());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_RHSAdjoint() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 1},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}),
.dimensions = {1, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op21
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({7.0f, 11.0f, 15.0f, 8.0f, 12.0f, 16.0f, 9.0f, 13.0f, 17.0f, 10.0f, 14.0f, 18.0f}),
.dimensions = {1, 4, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // adj01
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj11
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op31
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({74.0f, 80.0f, 86.0f, 92.0f, 173.0f, 188.0f, 203.0f, 218.0f}),
.dimensions = {1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_RHSAdjoint = TestModelManager::get().add("batch_matmul_RHSAdjoint", get_test_model_RHSAdjoint());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_RHSAdjoint_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {5, 8},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({}),
.dimensions = {1, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op21
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({}),
.dimensions = {1, 4, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // adj01
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj11
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op31
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({74.0f, 80.0f, 86.0f, 92.0f, 173.0f, 188.0f, 203.0f, 218.0f}),
.dimensions = {1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op11_new
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}),
.dimensions = {1, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // placeholder6
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param6
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}, { // op21_new
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({7.0f, 11.0f, 15.0f, 8.0f, 12.0f, 16.0f, 9.0f, 13.0f, 17.0f, 10.0f, 14.0f, 18.0f}),
.dimensions = {1, 4, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // placeholder7
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param7
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {8, 9, 10},
.outputs = {1},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_RHSAdjoint_all_inputs_as_internal = TestModelManager::get().add("batch_matmul_RHSAdjoint_all_inputs_as_internal", get_test_model_RHSAdjoint_all_inputs_as_internal());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_RHSAdjoint_float16() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 1},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}),
.dimensions = {1, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // op21
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({7.0f, 11.0f, 15.0f, 8.0f, 12.0f, 16.0f, 9.0f, 13.0f, 17.0f, 10.0f, 14.0f, 18.0f}),
.dimensions = {1, 4, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // adj01
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj11
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op31
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({74.0f, 80.0f, 86.0f, 92.0f, 173.0f, 188.0f, 203.0f, 218.0f}),
.dimensions = {1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_RHSAdjoint_float16 = TestModelManager::get().add("batch_matmul_RHSAdjoint_float16", get_test_model_RHSAdjoint_float16());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_RHSAdjoint_float16_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {5, 8},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({}),
.dimensions = {1, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // op21
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({}),
.dimensions = {1, 4, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // adj01
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj11
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op31
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({74.0f, 80.0f, 86.0f, 92.0f, 173.0f, 188.0f, 203.0f, 218.0f}),
.dimensions = {1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // op11_new
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}),
.dimensions = {1, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // placeholder8
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // param8
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}, { // op21_new
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({7.0f, 11.0f, 15.0f, 8.0f, 12.0f, 16.0f, 9.0f, 13.0f, 17.0f, 10.0f, 14.0f, 18.0f}),
.dimensions = {1, 4, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // placeholder9
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // param9
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {8, 9, 10},
.outputs = {1},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_RHSAdjoint_float16_all_inputs_as_internal = TestModelManager::get().add("batch_matmul_RHSAdjoint_float16_all_inputs_as_internal", get_test_model_RHSAdjoint_float16_all_inputs_as_internal());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_RHSAdjoint_int32() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 1},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 2, 3, 4, 5, 6}),
.dimensions = {1, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // op21
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({7, 11, 15, 8, 12, 16, 9, 13, 17, 10, 14, 18}),
.dimensions = {1, 4, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // adj01
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj11
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op31
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({74, 80, 86, 92, 173, 188, 203, 218}),
.dimensions = {1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_RHSAdjoint_int32 = TestModelManager::get().add("batch_matmul_RHSAdjoint_int32", get_test_model_RHSAdjoint_int32());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_RHSAdjoint_quant8_signed() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 1},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({4, 8, 12, 16, 20, 24}),
.dimensions = {1, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // op21
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-50, -42, -34, -48, -40, -32, -46, -38, -30, -44, -36, -28}),
.dimensions = {1, 4, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -64
}, { // adj01
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj11
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op31
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-54, -48, -42, -36, 45, 60, 75, 90}),
.dimensions = {1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_RHSAdjoint_quant8_signed = TestModelManager::get().add("batch_matmul_RHSAdjoint_quant8_signed", get_test_model_RHSAdjoint_quant8_signed());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_RHSAdjoint_quant8_signed_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {5, 8},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // op21
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 4, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -64
}, { // adj01
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj11
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op31
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-54, -48, -42, -36, 45, 60, 75, 90}),
.dimensions = {1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // op11_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({4, 8, 12, 16, 20, 24}),
.dimensions = {1, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // placeholder10
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param10
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}, { // op21_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-50, -42, -34, -48, -40, -32, -46, -38, -30, -44, -36, -28}),
.dimensions = {1, 4, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -64
}, { // placeholder11
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-64}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -64
}, { // param11
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {8, 9, 10},
.outputs = {1},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_RHSAdjoint_quant8_signed_all_inputs_as_internal = TestModelManager::get().add("batch_matmul_RHSAdjoint_quant8_signed_all_inputs_as_internal", get_test_model_RHSAdjoint_quant8_signed_all_inputs_as_internal());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_LHSAdjoint() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 1},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.0f, 4.0f, 2.0f, 5.0f, 3.0f, 6.0f}),
.dimensions = {1, 3, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op22
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f}),
.dimensions = {1, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // adj02
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj12
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op32
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({74.0f, 80.0f, 86.0f, 92.0f, 173.0f, 188.0f, 203.0f, 218.0f}),
.dimensions = {1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_LHSAdjoint = TestModelManager::get().add("batch_matmul_LHSAdjoint", get_test_model_LHSAdjoint());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_LHSAdjoint_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {5, 8},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({}),
.dimensions = {1, 3, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op22
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({}),
.dimensions = {1, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // adj02
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj12
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op32
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({74.0f, 80.0f, 86.0f, 92.0f, 173.0f, 188.0f, 203.0f, 218.0f}),
.dimensions = {1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op12_new
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.0f, 4.0f, 2.0f, 5.0f, 3.0f, 6.0f}),
.dimensions = {1, 3, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // placeholder12
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param12
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}, { // op22_new
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f}),
.dimensions = {1, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // placeholder13
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param13
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {8, 9, 10},
.outputs = {1},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_LHSAdjoint_all_inputs_as_internal = TestModelManager::get().add("batch_matmul_LHSAdjoint_all_inputs_as_internal", get_test_model_LHSAdjoint_all_inputs_as_internal());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_LHSAdjoint_float16() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 1},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({1.0f, 4.0f, 2.0f, 5.0f, 3.0f, 6.0f}),
.dimensions = {1, 3, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // op22
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f}),
.dimensions = {1, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // adj02
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj12
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op32
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({74.0f, 80.0f, 86.0f, 92.0f, 173.0f, 188.0f, 203.0f, 218.0f}),
.dimensions = {1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_LHSAdjoint_float16 = TestModelManager::get().add("batch_matmul_LHSAdjoint_float16", get_test_model_LHSAdjoint_float16());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_LHSAdjoint_float16_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {5, 8},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({}),
.dimensions = {1, 3, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // op22
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({}),
.dimensions = {1, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // adj02
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj12
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op32
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({74.0f, 80.0f, 86.0f, 92.0f, 173.0f, 188.0f, 203.0f, 218.0f}),
.dimensions = {1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // op12_new
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({1.0f, 4.0f, 2.0f, 5.0f, 3.0f, 6.0f}),
.dimensions = {1, 3, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // placeholder14
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // param14
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}, { // op22_new
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f}),
.dimensions = {1, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // placeholder15
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // param15
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {8, 9, 10},
.outputs = {1},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_LHSAdjoint_float16_all_inputs_as_internal = TestModelManager::get().add("batch_matmul_LHSAdjoint_float16_all_inputs_as_internal", get_test_model_LHSAdjoint_float16_all_inputs_as_internal());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_LHSAdjoint_int32() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 1},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 4, 2, 5, 3, 6}),
.dimensions = {1, 3, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // op22
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}),
.dimensions = {1, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // adj02
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj12
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op32
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({74, 80, 86, 92, 173, 188, 203, 218}),
.dimensions = {1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_LHSAdjoint_int32 = TestModelManager::get().add("batch_matmul_LHSAdjoint_int32", get_test_model_LHSAdjoint_int32());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_LHSAdjoint_quant8_signed() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 1},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({4, 16, 8, 20, 12, 24}),
.dimensions = {1, 3, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // op22
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-50, -48, -46, -44, -42, -40, -38, -36, -34, -32, -30, -28}),
.dimensions = {1, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -64
}, { // adj02
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj12
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op32
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-54, -48, -42, -36, 45, 60, 75, 90}),
.dimensions = {1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_LHSAdjoint_quant8_signed = TestModelManager::get().add("batch_matmul_LHSAdjoint_quant8_signed", get_test_model_LHSAdjoint_quant8_signed());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_LHSAdjoint_quant8_signed_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {5, 8},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 3, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // op22
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -64
}, { // adj02
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj12
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op32
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-54, -48, -42, -36, 45, 60, 75, 90}),
.dimensions = {1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // op12_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({4, 16, 8, 20, 12, 24}),
.dimensions = {1, 3, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // placeholder16
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param16
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}, { // op22_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-50, -48, -46, -44, -42, -40, -38, -36, -34, -32, -30, -28}),
.dimensions = {1, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -64
}, { // placeholder17
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-64}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -64
}, { // param17
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {8, 9, 10},
.outputs = {1},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_LHSAdjoint_quant8_signed_all_inputs_as_internal = TestModelManager::get().add("batch_matmul_LHSAdjoint_quant8_signed_all_inputs_as_internal", get_test_model_LHSAdjoint_quant8_signed_all_inputs_as_internal());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_TwoBatchSize() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 1},
.operands = {{ // op13
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}),
.dimensions = {2, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op23
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f}),
.dimensions = {2, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // adj03
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj13
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op33
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({74.0f, 80.0f, 86.0f, 92.0f, 173.0f, 188.0f, 203.0f, 218.0f, 74.0f, 80.0f, 86.0f, 92.0f, 173.0f, 188.0f, 203.0f, 218.0f}),
.dimensions = {2, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_TwoBatchSize = TestModelManager::get().add("batch_matmul_TwoBatchSize", get_test_model_TwoBatchSize());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_TwoBatchSize_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {5, 8},
.operands = {{ // op13
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({}),
.dimensions = {2, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op23
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({}),
.dimensions = {2, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // adj03
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj13
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op33
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({74.0f, 80.0f, 86.0f, 92.0f, 173.0f, 188.0f, 203.0f, 218.0f, 74.0f, 80.0f, 86.0f, 92.0f, 173.0f, 188.0f, 203.0f, 218.0f}),
.dimensions = {2, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op13_new
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}),
.dimensions = {2, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // placeholder18
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param18
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}, { // op23_new
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f}),
.dimensions = {2, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // placeholder19
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param19
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {8, 9, 10},
.outputs = {1},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_TwoBatchSize_all_inputs_as_internal = TestModelManager::get().add("batch_matmul_TwoBatchSize_all_inputs_as_internal", get_test_model_TwoBatchSize_all_inputs_as_internal());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_TwoBatchSize_float16() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 1},
.operands = {{ // op13
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}),
.dimensions = {2, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // op23
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f}),
.dimensions = {2, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // adj03
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj13
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op33
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({74.0f, 80.0f, 86.0f, 92.0f, 173.0f, 188.0f, 203.0f, 218.0f, 74.0f, 80.0f, 86.0f, 92.0f, 173.0f, 188.0f, 203.0f, 218.0f}),
.dimensions = {2, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_TwoBatchSize_float16 = TestModelManager::get().add("batch_matmul_TwoBatchSize_float16", get_test_model_TwoBatchSize_float16());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_TwoBatchSize_float16_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {5, 8},
.operands = {{ // op13
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({}),
.dimensions = {2, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // op23
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({}),
.dimensions = {2, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // adj03
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj13
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op33
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({74.0f, 80.0f, 86.0f, 92.0f, 173.0f, 188.0f, 203.0f, 218.0f, 74.0f, 80.0f, 86.0f, 92.0f, 173.0f, 188.0f, 203.0f, 218.0f}),
.dimensions = {2, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // op13_new
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}),
.dimensions = {2, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // placeholder20
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // param20
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}, { // op23_new
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f}),
.dimensions = {2, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // placeholder21
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // param21
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {8, 9, 10},
.outputs = {1},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_TwoBatchSize_float16_all_inputs_as_internal = TestModelManager::get().add("batch_matmul_TwoBatchSize_float16_all_inputs_as_internal", get_test_model_TwoBatchSize_float16_all_inputs_as_internal());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_TwoBatchSize_int32() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 1},
.operands = {{ // op13
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6}),
.dimensions = {2, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // op23
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}),
.dimensions = {2, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // adj03
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj13
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op33
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({74, 80, 86, 92, 173, 188, 203, 218, 74, 80, 86, 92, 173, 188, 203, 218}),
.dimensions = {2, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_TwoBatchSize_int32 = TestModelManager::get().add("batch_matmul_TwoBatchSize_int32", get_test_model_TwoBatchSize_int32());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_TwoBatchSize_quant8_signed() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 1},
.operands = {{ // op13
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({4, 8, 12, 16, 20, 24, 4, 8, 12, 16, 20, 24}),
.dimensions = {2, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // op23
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-50, -48, -46, -44, -42, -40, -38, -36, -34, -32, -30, -28, -50, -48, -46, -44, -42, -40, -38, -36, -34, -32, -30, -28}),
.dimensions = {2, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -64
}, { // adj03
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj13
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op33
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-54, -48, -42, -36, 45, 60, 75, 90, -54, -48, -42, -36, 45, 60, 75, 90}),
.dimensions = {2, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_TwoBatchSize_quant8_signed = TestModelManager::get().add("batch_matmul_TwoBatchSize_quant8_signed", get_test_model_TwoBatchSize_quant8_signed());
} // namespace generated_tests::batch_matmul
namespace generated_tests::batch_matmul {
const TestModel& get_test_model_TwoBatchSize_quant8_signed_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {5, 8},
.operands = {{ // op13
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {2, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // op23
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {2, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -64
}, { // adj03
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // adj13
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op33
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-54, -48, -42, -36, 45, 60, 75, 90, -54, -48, -42, -36, 45, 60, 75, 90}),
.dimensions = {2, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // op13_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({4, 8, 12, 16, 20, 24, 4, 8, 12, 16, 20, 24}),
.dimensions = {2, 2, 3},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // placeholder22
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param22
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}, { // op23_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-50, -48, -46, -44, -42, -40, -38, -36, -34, -32, -30, -28, -50, -48, -46, -44, -42, -40, -38, -36, -34, -32, -30, -28}),
.dimensions = {2, 3, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -64
}, { // placeholder23
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-64}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -64
}, { // param23
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {8, 9, 10},
.outputs = {1},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::BATCH_MATMUL
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::AIDL_V2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_TwoBatchSize_quant8_signed_all_inputs_as_internal = TestModelManager::get().add("batch_matmul_TwoBatchSize_quant8_signed_all_inputs_as_internal", get_test_model_TwoBatchSize_quant8_signed_all_inputs_as_internal());
} // namespace generated_tests::batch_matmul