1 // Generated from transpose.mod.py
2 // DO NOT EDIT
3 // clang-format off
4 #include "TestHarness.h"
5 using namespace test_helper;
6
7 namespace generated_tests::transpose {
8
get_test_model()9 const TestModel& get_test_model() {
10 static TestModel model = {
11 .expectFailure = false,
12 .expectedMultinomialDistributionTolerance = 0,
13 .isRelaxed = false,
14 .main = {
15 .inputIndexes = {0},
16 .operands = {{ // input
17 .channelQuant = {},
18 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f}),
19 .dimensions = {1, 2, 2, 1},
20 .isIgnored = false,
21 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
22 .numberOfConsumers = 1,
23 .scale = 0.0f,
24 .type = TestOperandType::TENSOR_FLOAT32,
25 .zeroPoint = 0
26 }, { // perms
27 .channelQuant = {},
28 .data = TestBuffer::createFromVector<int32_t>({0, 2, 1, 3}),
29 .dimensions = {4},
30 .isIgnored = false,
31 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
32 .numberOfConsumers = 1,
33 .scale = 0.0f,
34 .type = TestOperandType::TENSOR_INT32,
35 .zeroPoint = 0
36 }, { // output
37 .channelQuant = {},
38 .data = TestBuffer::createFromVector<float>({1.0f, 3.0f, 2.0f, 4.0f}),
39 .dimensions = {1, 2, 2, 1},
40 .isIgnored = false,
41 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
42 .numberOfConsumers = 0,
43 .scale = 0.0f,
44 .type = TestOperandType::TENSOR_FLOAT32,
45 .zeroPoint = 0
46 }},
47 .operations = {{
48 .inputs = {0, 1},
49 .outputs = {2},
50 .type = TestOperationType::TRANSPOSE
51 }},
52 .outputIndexes = {2}
53 },
54 .minSupportedVersion = TestHalVersion::V1_1,
55 .referenced = {}
56 };
57 return model;
58 }
59
60 const auto dummy_test_model = TestModelManager::get().add("transpose", get_test_model());
61
62 } // namespace generated_tests::transpose
63
64 namespace generated_tests::transpose {
65
get_test_model_all_inputs_as_internal()66 const TestModel& get_test_model_all_inputs_as_internal() {
67 static TestModel model = {
68 .expectFailure = false,
69 .expectedMultinomialDistributionTolerance = 0,
70 .isRelaxed = false,
71 .main = {
72 .inputIndexes = {3},
73 .operands = {{ // input
74 .channelQuant = {},
75 .data = TestBuffer::createFromVector<float>({}),
76 .dimensions = {1, 2, 2, 1},
77 .isIgnored = false,
78 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
79 .numberOfConsumers = 1,
80 .scale = 0.0f,
81 .type = TestOperandType::TENSOR_FLOAT32,
82 .zeroPoint = 0
83 }, { // perms
84 .channelQuant = {},
85 .data = TestBuffer::createFromVector<int32_t>({0, 2, 1, 3}),
86 .dimensions = {4},
87 .isIgnored = false,
88 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
89 .numberOfConsumers = 1,
90 .scale = 0.0f,
91 .type = TestOperandType::TENSOR_INT32,
92 .zeroPoint = 0
93 }, { // output
94 .channelQuant = {},
95 .data = TestBuffer::createFromVector<float>({1.0f, 3.0f, 2.0f, 4.0f}),
96 .dimensions = {1, 2, 2, 1},
97 .isIgnored = false,
98 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
99 .numberOfConsumers = 0,
100 .scale = 0.0f,
101 .type = TestOperandType::TENSOR_FLOAT32,
102 .zeroPoint = 0
103 }, { // input_new
104 .channelQuant = {},
105 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f}),
106 .dimensions = {1, 2, 2, 1},
107 .isIgnored = false,
108 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
109 .numberOfConsumers = 1,
110 .scale = 0.0f,
111 .type = TestOperandType::TENSOR_FLOAT32,
112 .zeroPoint = 0
113 }, { // placeholder
114 .channelQuant = {},
115 .data = TestBuffer::createFromVector<float>({0.0f}),
116 .dimensions = {1},
117 .isIgnored = false,
118 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
119 .numberOfConsumers = 1,
120 .scale = 0.0f,
121 .type = TestOperandType::TENSOR_FLOAT32,
122 .zeroPoint = 0
123 }, { // param
124 .channelQuant = {},
125 .data = TestBuffer::createFromVector<int32_t>({0}),
126 .dimensions = {},
127 .isIgnored = false,
128 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
129 .numberOfConsumers = 1,
130 .scale = 0.0f,
131 .type = TestOperandType::INT32,
132 .zeroPoint = 0
133 }},
134 .operations = {{
135 .inputs = {3, 4, 5},
136 .outputs = {0},
137 .type = TestOperationType::ADD
138 }, {
139 .inputs = {0, 1},
140 .outputs = {2},
141 .type = TestOperationType::TRANSPOSE
142 }},
143 .outputIndexes = {2}
144 },
145 .minSupportedVersion = TestHalVersion::V1_1,
146 .referenced = {}
147 };
148 return model;
149 }
150
151 const auto dummy_test_model_all_inputs_as_internal = TestModelManager::get().add("transpose_all_inputs_as_internal", get_test_model_all_inputs_as_internal());
152
153 } // namespace generated_tests::transpose
154
155 namespace generated_tests::transpose {
156
get_test_model_all_tensors_as_inputs()157 const TestModel& get_test_model_all_tensors_as_inputs() {
158 static TestModel model = {
159 .expectFailure = false,
160 .expectedMultinomialDistributionTolerance = 0,
161 .isRelaxed = false,
162 .main = {
163 .inputIndexes = {0, 1},
164 .operands = {{ // input
165 .channelQuant = {},
166 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f}),
167 .dimensions = {1, 2, 2, 1},
168 .isIgnored = false,
169 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
170 .numberOfConsumers = 1,
171 .scale = 0.0f,
172 .type = TestOperandType::TENSOR_FLOAT32,
173 .zeroPoint = 0
174 }, { // perms
175 .channelQuant = {},
176 .data = TestBuffer::createFromVector<int32_t>({0, 2, 1, 3}),
177 .dimensions = {4},
178 .isIgnored = false,
179 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
180 .numberOfConsumers = 1,
181 .scale = 0.0f,
182 .type = TestOperandType::TENSOR_INT32,
183 .zeroPoint = 0
184 }, { // output
185 .channelQuant = {},
186 .data = TestBuffer::createFromVector<float>({1.0f, 3.0f, 2.0f, 4.0f}),
187 .dimensions = {1, 2, 2, 1},
188 .isIgnored = false,
189 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
190 .numberOfConsumers = 0,
191 .scale = 0.0f,
192 .type = TestOperandType::TENSOR_FLOAT32,
193 .zeroPoint = 0
194 }},
195 .operations = {{
196 .inputs = {0, 1},
197 .outputs = {2},
198 .type = TestOperationType::TRANSPOSE
199 }},
200 .outputIndexes = {2}
201 },
202 .minSupportedVersion = TestHalVersion::V1_1,
203 .referenced = {}
204 };
205 return model;
206 }
207
208 const auto dummy_test_model_all_tensors_as_inputs = TestModelManager::get().add("transpose_all_tensors_as_inputs", get_test_model_all_tensors_as_inputs());
209
210 } // namespace generated_tests::transpose
211
212 namespace generated_tests::transpose {
213
get_test_model_all_tensors_as_inputs_all_inputs_as_internal()214 const TestModel& get_test_model_all_tensors_as_inputs_all_inputs_as_internal() {
215 static TestModel model = {
216 .expectFailure = false,
217 .expectedMultinomialDistributionTolerance = 0,
218 .isRelaxed = false,
219 .main = {
220 .inputIndexes = {1, 3},
221 .operands = {{ // input
222 .channelQuant = {},
223 .data = TestBuffer::createFromVector<float>({}),
224 .dimensions = {1, 2, 2, 1},
225 .isIgnored = false,
226 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
227 .numberOfConsumers = 1,
228 .scale = 0.0f,
229 .type = TestOperandType::TENSOR_FLOAT32,
230 .zeroPoint = 0
231 }, { // perms
232 .channelQuant = {},
233 .data = TestBuffer::createFromVector<int32_t>({0, 2, 1, 3}),
234 .dimensions = {4},
235 .isIgnored = false,
236 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
237 .numberOfConsumers = 1,
238 .scale = 0.0f,
239 .type = TestOperandType::TENSOR_INT32,
240 .zeroPoint = 0
241 }, { // output
242 .channelQuant = {},
243 .data = TestBuffer::createFromVector<float>({1.0f, 3.0f, 2.0f, 4.0f}),
244 .dimensions = {1, 2, 2, 1},
245 .isIgnored = false,
246 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
247 .numberOfConsumers = 0,
248 .scale = 0.0f,
249 .type = TestOperandType::TENSOR_FLOAT32,
250 .zeroPoint = 0
251 }, { // input_new
252 .channelQuant = {},
253 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 3.0f, 4.0f}),
254 .dimensions = {1, 2, 2, 1},
255 .isIgnored = false,
256 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
257 .numberOfConsumers = 1,
258 .scale = 0.0f,
259 .type = TestOperandType::TENSOR_FLOAT32,
260 .zeroPoint = 0
261 }, { // placeholder1
262 .channelQuant = {},
263 .data = TestBuffer::createFromVector<float>({0.0f}),
264 .dimensions = {1},
265 .isIgnored = false,
266 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
267 .numberOfConsumers = 1,
268 .scale = 0.0f,
269 .type = TestOperandType::TENSOR_FLOAT32,
270 .zeroPoint = 0
271 }, { // param1
272 .channelQuant = {},
273 .data = TestBuffer::createFromVector<int32_t>({0}),
274 .dimensions = {},
275 .isIgnored = false,
276 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
277 .numberOfConsumers = 1,
278 .scale = 0.0f,
279 .type = TestOperandType::INT32,
280 .zeroPoint = 0
281 }},
282 .operations = {{
283 .inputs = {3, 4, 5},
284 .outputs = {0},
285 .type = TestOperationType::ADD
286 }, {
287 .inputs = {0, 1},
288 .outputs = {2},
289 .type = TestOperationType::TRANSPOSE
290 }},
291 .outputIndexes = {2}
292 },
293 .minSupportedVersion = TestHalVersion::V1_1,
294 .referenced = {}
295 };
296 return model;
297 }
298
299 const auto dummy_test_model_all_tensors_as_inputs_all_inputs_as_internal = TestModelManager::get().add("transpose_all_tensors_as_inputs_all_inputs_as_internal", get_test_model_all_tensors_as_inputs_all_inputs_as_internal());
300
301 } // namespace generated_tests::transpose
302
303