Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / eff204aa3ae75277b0cf689eed0e2073ff644ef8 / . / delegate / test / ComparisonTest.cpp
blob: a6eda939941bdcf51466799cfe64b13fd2b5e16c [file] [log] [blame]
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]1//
Teresa Charlinad1b3d72023-03-14 12:10:28 +0000[diff] [blame]2// Copyright © 2020, 2023 Arm Ltd and Contributors. All rights reserved.
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]3// SPDX-License-Identifier: MIT
4//
5
6#include "ComparisonTestHelper.hpp"
7
8#include <armnn_delegate.hpp>
9
10#include <flatbuffers/flatbuffers.h>
11#include <tensorflow/lite/interpreter.h>
12#include <tensorflow/lite/kernels/register.h>
13#include <tensorflow/lite/model.h>
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]14#include <tensorflow/lite/version.h>
15
16#include <doctest/doctest.h>
17
18namespace armnnDelegate
19{
20
21void EqualFP32Test(std::vector<armnn::BackendId>& backends)
22{
23 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
24 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
25 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
26
27 std::vector<float> input0Values =
28 {
29 1.f, 1.f, 1.f, 1.f, 5.f, 5.f, 5.f, 5.f,
30 3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f
31 };
32
33 std::vector<float> input1Values =
34 {
35 1.f, 1.f, 1.f, 1.f, 3.f, 3.f, 3.f, 3.f,
36 5.f, 5.f, 5.f, 5.f, 4.f, 4.f, 4.f, 4.f
37 };
38
39 std::vector<bool> expectedOutputValues =
40 {
41 1, 1, 1, 1, 0, 0, 0, 0,
42 0, 0, 0, 0, 1, 1, 1, 1
43 };
44
45
46 ComparisonTest<float>(tflite::BuiltinOperator_EQUAL,
47 ::tflite::TensorType_FLOAT32,
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]48 input0Shape,
49 input1Shape,
50 expectedOutputShape,
51 input0Values,
52 input1Values,
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]53 expectedOutputValues,
54 1.0f,
55 0,
56 backends);
57
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]58}
59
60void EqualBroadcastTest(std::vector<armnn::BackendId>& backends)
61{
62 std::vector<int32_t> input0Shape { 1, 2, 2, 3 };
63 std::vector<int32_t> input1Shape { 1, 1, 1, 3 };
64 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 3 };
65
66 std::vector<float> input0Values
67 {
68 1.f, 2.f, 3.f, 4.f, 5.f, 6.f,
69 7.f, 8.f, 9.f, 10.f, 11.f, 12.f
70 };
71 std::vector<float> input1Values { 4.f, 5.f, 6.f };
72 // Set output data
73 std::vector<bool> expectedOutputValues
74 {
75 0, 0, 0, 1, 1, 1,
76 0, 0, 0, 0, 0, 0
77 };
78 ComparisonTest<float>(tflite::BuiltinOperator_EQUAL,
79 ::tflite::TensorType_FLOAT32,
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]80 input0Shape,
81 input1Shape,
82 expectedOutputShape,
83 input0Values,
84 input1Values,
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]85 expectedOutputValues,
86 1.0f,
87 0,
88 backends);
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]89}
90
91void EqualInt32Test(std::vector<armnn::BackendId>& backends)
92{
93 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
94 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
95 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
96
97 std::vector<int32_t> input0Values = { 1, 5, 6, 4 };
98
99 std::vector<int32_t> input1Values = { 1, 3, 9, 4 };
100
101 std::vector<bool> expectedOutputValues = { 1, 0, 0, 1 };
102
103 ComparisonTest<int32_t>(tflite::BuiltinOperator_EQUAL,
104 ::tflite::TensorType_INT32,
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]105 input0Shape,
106 input1Shape,
107 expectedOutputShape,
108 input0Values,
109 input1Values,
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]110 expectedOutputValues,
111 1.0f,
112 0,
113 backends);
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]114}
115
116void NotEqualFP32Test(std::vector<armnn::BackendId>& backends)
117{
118 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
119 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
120 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
121
122 std::vector<float> input0Values =
123 {
124 1.f, 1.f, 1.f, 1.f, 5.f, 5.f, 5.f, 5.f,
125 3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f
126 };
127
128 std::vector<float> input1Values =
129 {
130 1.f, 1.f, 1.f, 1.f, 3.f, 3.f, 3.f, 3.f,
131 5.f, 5.f, 5.f, 5.f, 4.f, 4.f, 4.f, 4.f
132 };
133
134 std::vector<bool> expectedOutputValues =
135 {
136 0, 0, 0, 0, 1, 1, 1, 1,
137 1, 1, 1, 1, 0, 0, 0, 0
138 };
139
140 ComparisonTest<float>(tflite::BuiltinOperator_NOT_EQUAL,
141 ::tflite::TensorType_FLOAT32,
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]142 input0Shape,
143 input1Shape,
144 expectedOutputShape,
145 input0Values,
146 input1Values,
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]147 expectedOutputValues,
148 1.0f,
149 0,
150 backends);
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]151}
152
153void NotEqualBroadcastTest(std::vector<armnn::BackendId>& backends)
154{
155 std::vector<int32_t> input0Shape { 1, 2, 2, 3 };
156 std::vector<int32_t> input1Shape { 1, 1, 1, 3 };
157 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 3 };
158
159 std::vector<float> input0Values
160 {
161 1.f, 2.f, 3.f, 4.f, 5.f, 6.f,
162 7.f, 8.f, 9.f, 10.f, 11.f, 12.f
163 };
164 std::vector<float> input1Values { 4.f, 5.f, 6.f };
165 // Set output data
166 std::vector<bool> expectedOutputValues
167 {
168 1, 1, 1, 0, 0, 0,
169 1, 1, 1, 1, 1, 1
170 };
171 ComparisonTest<float>(tflite::BuiltinOperator_NOT_EQUAL,
172 ::tflite::TensorType_FLOAT32,
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]173 input0Shape,
174 input1Shape,
175 expectedOutputShape,
176 input0Values,
177 input1Values,
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]178 expectedOutputValues,
179 1.0f,
180 0,
181 backends);
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]182}
183
184void NotEqualInt32Test(std::vector<armnn::BackendId>& backends)
185{
186 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
187 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
188 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
189
190 std::vector<int32_t> input0Values = { 1, 5, 6, 4 };
191
192 std::vector<int32_t> input1Values = { 1, 3, 9, 4 };
193
194 std::vector<bool> expectedOutputValues = { 0, 1, 1, 0 };
195
196 ComparisonTest<int32_t>(tflite::BuiltinOperator_NOT_EQUAL,
197 ::tflite::TensorType_INT32,
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]198 input0Shape,
199 input1Shape,
200 expectedOutputShape,
201 input0Values,
202 input1Values,
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]203 expectedOutputValues,
204 1.0f,
205 0,
206 backends);
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]207}
208
209void GreaterFP32Test(std::vector<armnn::BackendId>& backends)
210{
211 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
212 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
213 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
214
215 std::vector<float> input0Values = { 1, 5, 6, 4 };
216
217 std::vector<float> input1Values = { 1, 3, 9, 4 };
218
219 std::vector<bool> expectedOutputValues = { 0, 1, 0, 0 };
220
221 ComparisonTest<float>(tflite::BuiltinOperator_GREATER,
222 ::tflite::TensorType_FLOAT32,
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]223 input0Shape,
224 input1Shape,
225 expectedOutputShape,
226 input0Values,
227 input1Values,
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]228 expectedOutputValues,
229 1.0f,
230 0,
231 backends);
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]232}
233
234void GreaterBroadcastTest(std::vector<armnn::BackendId>& backends)
235{
236 std::vector<int32_t> input0Shape { 1, 2, 2, 3 };
237 std::vector<int32_t> input1Shape { 1, 1, 1, 3 };
238 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 3 };
239
240 std::vector<float> input0Values
241 {
242 1.f, 2.f, 3.f, 4.f, 5.f, 6.f,
243 7.f, 8.f, 9.f, 10.f, 11.f, 12.f
244 };
245 std::vector<float> input1Values { 4.f, 5.f, 6.f };
246
247 std::vector<bool> expectedOutputValues
248 {
249 0, 0, 0, 0, 0, 0,
250 1, 1, 1, 1, 1, 1
251 };
252 ComparisonTest<float>(tflite::BuiltinOperator_GREATER,
253 ::tflite::TensorType_FLOAT32,
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]254 input0Shape,
255 input1Shape,
256 expectedOutputShape,
257 input0Values,
258 input1Values,
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]259 expectedOutputValues,
260 1.0f,
261 0,
262 backends);
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]263}
264
265void GreaterInt32Test(std::vector<armnn::BackendId>& backends)
266{
267 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
268 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
269 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
270
271 std::vector<int32_t> input0Values = { 1, 5, 6, 4 };
272
273 std::vector<int32_t> input1Values = { 1, 3, 9, 4 };
274
275 std::vector<bool> expectedOutputValues = { 0, 1, 0, 0 };
276
277 ComparisonTest<int32_t>(tflite::BuiltinOperator_GREATER,
278 ::tflite::TensorType_INT32,
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]279 input0Shape,
280 input1Shape,
281 expectedOutputShape,
282 input0Values,
283 input1Values,
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]284 expectedOutputValues,
285 1.0f,
286 0,
287 backends);
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]288}
289
290void GreaterEqualFP32Test(std::vector<armnn::BackendId>& backends)
291{
292 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
293 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
294 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
295
296 std::vector<float> input0Values = { 1.f, 5.f, 6.f, 4.f };
297
298 std::vector<float> input1Values = { 1.f, 3.f, 9.f, 4.f };
299
300 std::vector<bool> expectedOutputValues = { true, true, false, true };
301
302 ComparisonTest<float>(tflite::BuiltinOperator_GREATER_EQUAL,
303 ::tflite::TensorType_FLOAT32,
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]304 input0Shape,
305 input1Shape,
306 expectedOutputShape,
307 input0Values,
308 input1Values,
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]309 expectedOutputValues,
310 1.0f,
311 0,
312 backends);
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]313}
314
315void GreaterEqualBroadcastTest(std::vector<armnn::BackendId>& backends)
316{
317 std::vector<int32_t> input0Shape { 1, 2, 2, 3 };
318 std::vector<int32_t> input1Shape { 1, 1, 1, 3 };
319 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 3 };
320
321 std::vector<float> input0Values
322 {
323 1.f, 2.f, 3.f, 4.f, 5.f, 6.f,
324 7.f, 8.f, 9.f, 10.f, 11.f, 12.f
325 };
326 std::vector<float> input1Values { 4.f, 5.f, 6.f };
327 // Set output data
328 std::vector<bool> expectedOutputValues
329 {
330 0, 0, 0, 1, 1, 1,
331 1, 1, 1, 1, 1, 1
332 };
333
334 ComparisonTest<float>(tflite::BuiltinOperator_GREATER_EQUAL,
335 ::tflite::TensorType_FLOAT32,
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]336 input0Shape,
337 input1Shape,
338 expectedOutputShape,
339 input0Values,
340 input1Values,
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]341 expectedOutputValues,
342 1.0f,
343 0,
344 backends);
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]345}
346
347void GreaterEqualInt32Test(std::vector<armnn::BackendId>& backends)
348{
349 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
350 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
351 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
352
353 std::vector<int32_t> input0Values = { 1, 5, 6, 3 };
354
355 std::vector<int32_t> input1Values = { 1, 3, 9, 4 };
356
357 std::vector<bool> expectedOutputValues = { 1, 1, 0, 0 };
358
359 ComparisonTest<int32_t>(tflite::BuiltinOperator_GREATER_EQUAL,
360 ::tflite::TensorType_INT32,
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]361 input0Shape,
362 input1Shape,
363 expectedOutputShape,
364 input0Values,
365 input1Values,
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]366 expectedOutputValues,
367 1.0f,
368 0,
369 backends);
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]370}
371
372void LessFP32Test(std::vector<armnn::BackendId>& backends)
373{
374 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
375 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
376 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
377
378 std::vector<float> input0Values = { 1.f, 5.f, 6.f, 4.f };
379
380 std::vector<float> input1Values = { 1.f, 3.f, 9.f, 4.f };
381
382 std::vector<bool> expectedOutputValues = { false, false, true, false };
383
384 ComparisonTest<float>(tflite::BuiltinOperator_LESS,
385 ::tflite::TensorType_FLOAT32,
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]386 input0Shape,
387 input1Shape,
388 expectedOutputShape,
389 input0Values,
390 input1Values,
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]391 expectedOutputValues,
392 1.0f,
393 0,
394 backends);
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]395}
396
397void LessBroadcastTest(std::vector<armnn::BackendId>& backends)
398{
399 std::vector<int32_t> input0Shape { 1, 2, 2, 3 };
400 std::vector<int32_t> input1Shape { 1, 1, 1, 3 };
401 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 3 };
402
403 std::vector<float> input0Values
404 {
405 1.f, 2.f, 3.f, 4.f, 5.f, 6.f,
406 7.f, 8.f, 9.f, 10.f, 11.f, 12.f
407 };
408 std::vector<float> input1Values { 4.f, 5.f, 6.f };
409
410 std::vector<bool> expectedOutputValues
411 {
412 true, true, true, false, false, false,
413 false, false, false, false, false, false
414 };
415
416 ComparisonTest<float>(tflite::BuiltinOperator_LESS,
417 ::tflite::TensorType_FLOAT32,
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]418 input0Shape,
419 input1Shape,
420 expectedOutputShape,
421 input0Values,
422 input1Values,
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]423 expectedOutputValues,
424 1.0f,
425 0,
426 backends);
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]427}
428
429void LessInt32Test(std::vector<armnn::BackendId>& backends)
430{
431 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
432 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
433 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
434
435 std::vector<int32_t> input0Values = { 1, 5, 6, 3 };
436
437 std::vector<int32_t> input1Values = { 1, 3, 9, 4 };
438
439 std::vector<bool> expectedOutputValues = { false, false, true, true };
440
441 ComparisonTest<int32_t>(tflite::BuiltinOperator_LESS,
442 ::tflite::TensorType_INT32,
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]443 input0Shape,
444 input1Shape,
445 expectedOutputShape,
446 input0Values,
447 input1Values,
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]448 expectedOutputValues,
449 1.0f,
450 0,
451 backends);
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]452}
453
454void LessEqualFP32Test(std::vector<armnn::BackendId>& backends)
455{
456 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
457 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
458 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
459
460 std::vector<float> input0Values = { 1.f, 5.f, 6.f, 4.f };
461
462 std::vector<float> input1Values = { 1.f, 3.f, 9.f, 4.f };
463
464 std::vector<bool> expectedOutputValues = { true, false, true, true };
465
466 ComparisonTest<float>(tflite::BuiltinOperator_LESS_EQUAL,
467 ::tflite::TensorType_FLOAT32,
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]468 input0Shape,
469 input1Shape,
470 expectedOutputShape,
471 input0Values,
472 input1Values,
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]473 expectedOutputValues,
474 1.0f,
475 0,
476 backends);
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]477}
478
479void LessEqualBroadcastTest(std::vector<armnn::BackendId>& backends)
480{
481 std::vector<int32_t> input0Shape { 1, 2, 2, 3 };
482 std::vector<int32_t> input1Shape { 1, 1, 1, 3 };
483 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 3 };
484
485 std::vector<float> input0Values
486 {
487 1.f, 2.f, 3.f, 4.f, 5.f, 6.f,
488 7.f, 8.f, 9.f, 10.f, 11.f, 12.f
489 };
490 std::vector<float> input1Values { 4.f, 5.f, 6.f };
491
492 std::vector<bool> expectedOutputValues
493 {
494 true, true, true, true, true, true,
495 false, false, false, false, false, false
496 };
497
498 ComparisonTest<float>(tflite::BuiltinOperator_LESS_EQUAL,
499 ::tflite::TensorType_FLOAT32,
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]500 input0Shape,
501 input1Shape,
502 expectedOutputShape,
503 input0Values,
504 input1Values,
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]505 expectedOutputValues,
506 1.0f,
507 0,
508 backends);
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]509}
510
511void LessEqualInt32Test(std::vector<armnn::BackendId>& backends)
512{
513 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
514 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
515 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
516
517 std::vector<int32_t> input0Values = { 1, 5, 6, 3 };
518
519 std::vector<int32_t> input1Values = { 1, 3, 9, 4 };
520
521 std::vector<bool> expectedOutputValues = { true, false, true, true };
522
523 ComparisonTest<int32_t>(tflite::BuiltinOperator_LESS_EQUAL,
524 ::tflite::TensorType_INT32,
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]525 input0Shape,
526 input1Shape,
527 expectedOutputShape,
528 input0Values,
529 input1Values,
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]530 expectedOutputValues,
531 1.0f,
532 0,
533 backends);
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]534}
535
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]536TEST_SUITE("Comparison_Tests")
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]537{
538
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]539TEST_CASE ("EQUAL_FP32_Test")
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]540{
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]541 std::vector<armnn::BackendId> backends = { };
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]542 EqualFP32Test(backends);
543}
544
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]545TEST_CASE ("EQUAL_Broadcast_Test")
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]546{
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]547 std::vector<armnn::BackendId> backends = { };
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]548 EqualBroadcastTest(backends);
549}
550
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]551TEST_CASE ("EQUAL_INT32_Test")
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]552{
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]553 std::vector<armnn::BackendId> backends = { };
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]554 EqualInt32Test(backends);
555}
556
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]557TEST_CASE ("NOT_EQUAL_FP32_Test")
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]558{
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]559 std::vector<armnn::BackendId> backends = { };
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]560 NotEqualFP32Test(backends);
561}
562
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]563TEST_CASE ("NOT_EQUAL_Broadcast_Test")
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]564{
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]565 std::vector<armnn::BackendId> backends = { };
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]566 NotEqualBroadcastTest(backends);
567}
568
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]569TEST_CASE ("NOT_EQUAL_INT32_Test")
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]570{
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]571 std::vector<armnn::BackendId> backends = { };
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]572 NotEqualInt32Test(backends);
573}
574
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]575TEST_CASE ("GREATER_FP32_Test")
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]576{
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]577 std::vector<armnn::BackendId> backends = { };
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]578 GreaterFP32Test(backends);
579}
580
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]581TEST_CASE ("GREATER_Broadcast_Test")
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]582{
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]583 std::vector<armnn::BackendId> backends = { };
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]584 GreaterBroadcastTest(backends);
585}
586
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]587TEST_CASE ("GREATER_INT32_Test")
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]588{
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]589 std::vector<armnn::BackendId> backends = { };
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]590 GreaterInt32Test(backends);
591}
592
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]593TEST_CASE ("GREATER_EQUAL_FP32_Test")
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]594{
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]595 std::vector<armnn::BackendId> backends = { };
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]596 GreaterEqualFP32Test(backends);
597}
598
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]599TEST_CASE ("GREATER_EQUAL_Broadcast_Test")
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]600{
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]601 std::vector<armnn::BackendId> backends = { };
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]602 GreaterEqualBroadcastTest(backends);
603}
604
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]605TEST_CASE ("GREATER_EQUAL_INT32_Test")
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]606{
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]607 std::vector<armnn::BackendId> backends = { };
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]608 GreaterEqualInt32Test(backends);
609}
610
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]611TEST_CASE ("LESS_FP32_Test")
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]612{
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]613 std::vector<armnn::BackendId> backends = { };
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]614 LessFP32Test(backends);
615}
616
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]617TEST_CASE ("LESS_Broadcast_Test")
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]618{
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]619 std::vector<armnn::BackendId> backends = { };
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]620 LessBroadcastTest(backends);
621}
622
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]623TEST_CASE ("LESS_INT32_Test")
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]624{
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]625 std::vector<armnn::BackendId> backends = { };
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]626 LessInt32Test(backends);
627}
628
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]629TEST_CASE ("LESS_EQUAL_FP32_Test")
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]630{
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]631 std::vector<armnn::BackendId> backends = { };
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]632 LessEqualFP32Test(backends);
633}
634
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]635TEST_CASE ("LESS_EQUAL_Broadcast_Test")
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]636{
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]637 std::vector<armnn::BackendId> backends = { };
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]638 LessEqualBroadcastTest(backends);
639}
640
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]641TEST_CASE ("LESS_EQUAL_INT32_Test")
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]642{
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]643 std::vector<armnn::BackendId> backends = { };
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]644 LessEqualInt32Test(backends);
645}
Colm Donelaneff204a2023-11-28 15:46:09 +0000[diff] [blame^]646} // End TEST_SUITE("Comparison_Tests")
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]647
648} // namespace armnnDelegate