Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / f0d8ec1f4be3ce5794a48c3d3449fe93f2e58d04 / . / delegate / test / ComparisonTest.cpp
blob: 8374025cf01da34abe0201fe72cbaa43ebeb3432 [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,
48 backends,
49 input0Shape,
50 input1Shape,
51 expectedOutputShape,
52 input0Values,
53 input1Values,
54 expectedOutputValues);
55}
56
57void EqualBroadcastTest(std::vector<armnn::BackendId>& backends)
58{
59 std::vector<int32_t> input0Shape { 1, 2, 2, 3 };
60 std::vector<int32_t> input1Shape { 1, 1, 1, 3 };
61 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 3 };
62
63 std::vector<float> input0Values
64 {
65 1.f, 2.f, 3.f, 4.f, 5.f, 6.f,
66 7.f, 8.f, 9.f, 10.f, 11.f, 12.f
67 };
68 std::vector<float> input1Values { 4.f, 5.f, 6.f };
69 // Set output data
70 std::vector<bool> expectedOutputValues
71 {
72 0, 0, 0, 1, 1, 1,
73 0, 0, 0, 0, 0, 0
74 };
75 ComparisonTest<float>(tflite::BuiltinOperator_EQUAL,
76 ::tflite::TensorType_FLOAT32,
77 backends,
78 input0Shape,
79 input1Shape,
80 expectedOutputShape,
81 input0Values,
82 input1Values,
83 expectedOutputValues);
84}
85
86void EqualInt32Test(std::vector<armnn::BackendId>& backends)
87{
88 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
89 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
90 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
91
92 std::vector<int32_t> input0Values = { 1, 5, 6, 4 };
93
94 std::vector<int32_t> input1Values = { 1, 3, 9, 4 };
95
96 std::vector<bool> expectedOutputValues = { 1, 0, 0, 1 };
97
98 ComparisonTest<int32_t>(tflite::BuiltinOperator_EQUAL,
99 ::tflite::TensorType_INT32,
100 backends,
101 input0Shape,
102 input1Shape,
103 expectedOutputShape,
104 input0Values,
105 input1Values,
106 expectedOutputValues);
107}
108
109void NotEqualFP32Test(std::vector<armnn::BackendId>& backends)
110{
111 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
112 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
113 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
114
115 std::vector<float> input0Values =
116 {
117 1.f, 1.f, 1.f, 1.f, 5.f, 5.f, 5.f, 5.f,
118 3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f
119 };
120
121 std::vector<float> input1Values =
122 {
123 1.f, 1.f, 1.f, 1.f, 3.f, 3.f, 3.f, 3.f,
124 5.f, 5.f, 5.f, 5.f, 4.f, 4.f, 4.f, 4.f
125 };
126
127 std::vector<bool> expectedOutputValues =
128 {
129 0, 0, 0, 0, 1, 1, 1, 1,
130 1, 1, 1, 1, 0, 0, 0, 0
131 };
132
133 ComparisonTest<float>(tflite::BuiltinOperator_NOT_EQUAL,
134 ::tflite::TensorType_FLOAT32,
135 backends,
136 input0Shape,
137 input1Shape,
138 expectedOutputShape,
139 input0Values,
140 input1Values,
141 expectedOutputValues);
142}
143
144void NotEqualBroadcastTest(std::vector<armnn::BackendId>& backends)
145{
146 std::vector<int32_t> input0Shape { 1, 2, 2, 3 };
147 std::vector<int32_t> input1Shape { 1, 1, 1, 3 };
148 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 3 };
149
150 std::vector<float> input0Values
151 {
152 1.f, 2.f, 3.f, 4.f, 5.f, 6.f,
153 7.f, 8.f, 9.f, 10.f, 11.f, 12.f
154 };
155 std::vector<float> input1Values { 4.f, 5.f, 6.f };
156 // Set output data
157 std::vector<bool> expectedOutputValues
158 {
159 1, 1, 1, 0, 0, 0,
160 1, 1, 1, 1, 1, 1
161 };
162 ComparisonTest<float>(tflite::BuiltinOperator_NOT_EQUAL,
163 ::tflite::TensorType_FLOAT32,
164 backends,
165 input0Shape,
166 input1Shape,
167 expectedOutputShape,
168 input0Values,
169 input1Values,
170 expectedOutputValues);
171}
172
173void NotEqualInt32Test(std::vector<armnn::BackendId>& backends)
174{
175 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
176 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
177 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
178
179 std::vector<int32_t> input0Values = { 1, 5, 6, 4 };
180
181 std::vector<int32_t> input1Values = { 1, 3, 9, 4 };
182
183 std::vector<bool> expectedOutputValues = { 0, 1, 1, 0 };
184
185 ComparisonTest<int32_t>(tflite::BuiltinOperator_NOT_EQUAL,
186 ::tflite::TensorType_INT32,
187 backends,
188 input0Shape,
189 input1Shape,
190 expectedOutputShape,
191 input0Values,
192 input1Values,
193 expectedOutputValues);
194}
195
196void GreaterFP32Test(std::vector<armnn::BackendId>& backends)
197{
198 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
199 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
200 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
201
202 std::vector<float> input0Values = { 1, 5, 6, 4 };
203
204 std::vector<float> input1Values = { 1, 3, 9, 4 };
205
206 std::vector<bool> expectedOutputValues = { 0, 1, 0, 0 };
207
208 ComparisonTest<float>(tflite::BuiltinOperator_GREATER,
209 ::tflite::TensorType_FLOAT32,
210 backends,
211 input0Shape,
212 input1Shape,
213 expectedOutputShape,
214 input0Values,
215 input1Values,
216 expectedOutputValues);
217}
218
219void GreaterBroadcastTest(std::vector<armnn::BackendId>& backends)
220{
221 std::vector<int32_t> input0Shape { 1, 2, 2, 3 };
222 std::vector<int32_t> input1Shape { 1, 1, 1, 3 };
223 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 3 };
224
225 std::vector<float> input0Values
226 {
227 1.f, 2.f, 3.f, 4.f, 5.f, 6.f,
228 7.f, 8.f, 9.f, 10.f, 11.f, 12.f
229 };
230 std::vector<float> input1Values { 4.f, 5.f, 6.f };
231
232 std::vector<bool> expectedOutputValues
233 {
234 0, 0, 0, 0, 0, 0,
235 1, 1, 1, 1, 1, 1
236 };
237 ComparisonTest<float>(tflite::BuiltinOperator_GREATER,
238 ::tflite::TensorType_FLOAT32,
239 backends,
240 input0Shape,
241 input1Shape,
242 expectedOutputShape,
243 input0Values,
244 input1Values,
245 expectedOutputValues);
246}
247
248void GreaterInt32Test(std::vector<armnn::BackendId>& backends)
249{
250 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
251 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
252 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
253
254 std::vector<int32_t> input0Values = { 1, 5, 6, 4 };
255
256 std::vector<int32_t> input1Values = { 1, 3, 9, 4 };
257
258 std::vector<bool> expectedOutputValues = { 0, 1, 0, 0 };
259
260 ComparisonTest<int32_t>(tflite::BuiltinOperator_GREATER,
261 ::tflite::TensorType_INT32,
262 backends,
263 input0Shape,
264 input1Shape,
265 expectedOutputShape,
266 input0Values,
267 input1Values,
268 expectedOutputValues);
269}
270
271void GreaterEqualFP32Test(std::vector<armnn::BackendId>& backends)
272{
273 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
274 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
275 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
276
277 std::vector<float> input0Values = { 1.f, 5.f, 6.f, 4.f };
278
279 std::vector<float> input1Values = { 1.f, 3.f, 9.f, 4.f };
280
281 std::vector<bool> expectedOutputValues = { true, true, false, true };
282
283 ComparisonTest<float>(tflite::BuiltinOperator_GREATER_EQUAL,
284 ::tflite::TensorType_FLOAT32,
285 backends,
286 input0Shape,
287 input1Shape,
288 expectedOutputShape,
289 input0Values,
290 input1Values,
291 expectedOutputValues);
292}
293
294void GreaterEqualBroadcastTest(std::vector<armnn::BackendId>& backends)
295{
296 std::vector<int32_t> input0Shape { 1, 2, 2, 3 };
297 std::vector<int32_t> input1Shape { 1, 1, 1, 3 };
298 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 3 };
299
300 std::vector<float> input0Values
301 {
302 1.f, 2.f, 3.f, 4.f, 5.f, 6.f,
303 7.f, 8.f, 9.f, 10.f, 11.f, 12.f
304 };
305 std::vector<float> input1Values { 4.f, 5.f, 6.f };
306 // Set output data
307 std::vector<bool> expectedOutputValues
308 {
309 0, 0, 0, 1, 1, 1,
310 1, 1, 1, 1, 1, 1
311 };
312
313 ComparisonTest<float>(tflite::BuiltinOperator_GREATER_EQUAL,
314 ::tflite::TensorType_FLOAT32,
315 backends,
316 input0Shape,
317 input1Shape,
318 expectedOutputShape,
319 input0Values,
320 input1Values,
321 expectedOutputValues);
322}
323
324void GreaterEqualInt32Test(std::vector<armnn::BackendId>& backends)
325{
326 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
327 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
328 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
329
330 std::vector<int32_t> input0Values = { 1, 5, 6, 3 };
331
332 std::vector<int32_t> input1Values = { 1, 3, 9, 4 };
333
334 std::vector<bool> expectedOutputValues = { 1, 1, 0, 0 };
335
336 ComparisonTest<int32_t>(tflite::BuiltinOperator_GREATER_EQUAL,
337 ::tflite::TensorType_INT32,
338 backends,
339 input0Shape,
340 input1Shape,
341 expectedOutputShape,
342 input0Values,
343 input1Values,
344 expectedOutputValues);
345}
346
347void LessFP32Test(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<float> input0Values = { 1.f, 5.f, 6.f, 4.f };
354
355 std::vector<float> input1Values = { 1.f, 3.f, 9.f, 4.f };
356
357 std::vector<bool> expectedOutputValues = { false, false, true, false };
358
359 ComparisonTest<float>(tflite::BuiltinOperator_LESS,
360 ::tflite::TensorType_FLOAT32,
361 backends,
362 input0Shape,
363 input1Shape,
364 expectedOutputShape,
365 input0Values,
366 input1Values,
367 expectedOutputValues);
368}
369
370void LessBroadcastTest(std::vector<armnn::BackendId>& backends)
371{
372 std::vector<int32_t> input0Shape { 1, 2, 2, 3 };
373 std::vector<int32_t> input1Shape { 1, 1, 1, 3 };
374 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 3 };
375
376 std::vector<float> input0Values
377 {
378 1.f, 2.f, 3.f, 4.f, 5.f, 6.f,
379 7.f, 8.f, 9.f, 10.f, 11.f, 12.f
380 };
381 std::vector<float> input1Values { 4.f, 5.f, 6.f };
382
383 std::vector<bool> expectedOutputValues
384 {
385 true, true, true, false, false, false,
386 false, false, false, false, false, false
387 };
388
389 ComparisonTest<float>(tflite::BuiltinOperator_LESS,
390 ::tflite::TensorType_FLOAT32,
391 backends,
392 input0Shape,
393 input1Shape,
394 expectedOutputShape,
395 input0Values,
396 input1Values,
397 expectedOutputValues);
398}
399
400void LessInt32Test(std::vector<armnn::BackendId>& backends)
401{
402 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
403 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
404 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
405
406 std::vector<int32_t> input0Values = { 1, 5, 6, 3 };
407
408 std::vector<int32_t> input1Values = { 1, 3, 9, 4 };
409
410 std::vector<bool> expectedOutputValues = { false, false, true, true };
411
412 ComparisonTest<int32_t>(tflite::BuiltinOperator_LESS,
413 ::tflite::TensorType_INT32,
414 backends,
415 input0Shape,
416 input1Shape,
417 expectedOutputShape,
418 input0Values,
419 input1Values,
420 expectedOutputValues);
421}
422
423void LessEqualFP32Test(std::vector<armnn::BackendId>& backends)
424{
425 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
426 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
427 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
428
429 std::vector<float> input0Values = { 1.f, 5.f, 6.f, 4.f };
430
431 std::vector<float> input1Values = { 1.f, 3.f, 9.f, 4.f };
432
433 std::vector<bool> expectedOutputValues = { true, false, true, true };
434
435 ComparisonTest<float>(tflite::BuiltinOperator_LESS_EQUAL,
436 ::tflite::TensorType_FLOAT32,
437 backends,
438 input0Shape,
439 input1Shape,
440 expectedOutputShape,
441 input0Values,
442 input1Values,
443 expectedOutputValues);
444}
445
446void LessEqualBroadcastTest(std::vector<armnn::BackendId>& backends)
447{
448 std::vector<int32_t> input0Shape { 1, 2, 2, 3 };
449 std::vector<int32_t> input1Shape { 1, 1, 1, 3 };
450 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 3 };
451
452 std::vector<float> input0Values
453 {
454 1.f, 2.f, 3.f, 4.f, 5.f, 6.f,
455 7.f, 8.f, 9.f, 10.f, 11.f, 12.f
456 };
457 std::vector<float> input1Values { 4.f, 5.f, 6.f };
458
459 std::vector<bool> expectedOutputValues
460 {
461 true, true, true, true, true, true,
462 false, false, false, false, false, false
463 };
464
465 ComparisonTest<float>(tflite::BuiltinOperator_LESS_EQUAL,
466 ::tflite::TensorType_FLOAT32,
467 backends,
468 input0Shape,
469 input1Shape,
470 expectedOutputShape,
471 input0Values,
472 input1Values,
473 expectedOutputValues);
474}
475
476void LessEqualInt32Test(std::vector<armnn::BackendId>& backends)
477{
478 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
479 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
480 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
481
482 std::vector<int32_t> input0Values = { 1, 5, 6, 3 };
483
484 std::vector<int32_t> input1Values = { 1, 3, 9, 4 };
485
486 std::vector<bool> expectedOutputValues = { true, false, true, true };
487
488 ComparisonTest<int32_t>(tflite::BuiltinOperator_LESS_EQUAL,
489 ::tflite::TensorType_INT32,
490 backends,
491 input0Shape,
492 input1Shape,
493 expectedOutputShape,
494 input0Values,
495 input1Values,
496 expectedOutputValues);
497}
498
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]499TEST_SUITE("Comparison_CpuRefTests")
500{
501
502TEST_CASE ("EQUAL_FP32_CpuRef_Test")
503{
504 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
505 EqualFP32Test(backends);
506}
507
508TEST_CASE ("EQUAL_Broadcast_CpuRef_Test")
509{
510 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
511 EqualBroadcastTest(backends);
512}
513
514TEST_CASE ("EQUAL_INT32_CpuRef_Test")
515{
516 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
517 EqualInt32Test(backends);
518}
519
520TEST_CASE ("NOT_EQUAL_FP32_CpuRef_Test")
521{
522 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
523 NotEqualFP32Test(backends);
524}
525
526TEST_CASE ("NOT_EQUAL_Broadcast_CpuRef_Test")
527{
528 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
529 NotEqualBroadcastTest(backends);
530}
531
532TEST_CASE ("NOT_EQUAL_INT32_CpuRef_Test")
533{
534 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
535 NotEqualInt32Test(backends);
536}
537
538TEST_CASE ("GREATER_FP32_CpuRef_Test")
539{
540 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
541 GreaterFP32Test(backends);
542}
543
544TEST_CASE ("GREATER_Broadcast_CpuRef_Test")
545{
546 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
547 GreaterBroadcastTest(backends);
548}
549
550TEST_CASE ("GREATER_INT32_CpuRef_Test")
551{
552 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
553 GreaterInt32Test(backends);
554}
555
556TEST_CASE ("GREATER_EQUAL_FP32_CpuRef_Test")
557{
558 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
559 GreaterEqualFP32Test(backends);
560}
561
562TEST_CASE ("GREATER_EQUAL_Broadcast_CpuRef_Test")
563{
564 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
565 GreaterEqualBroadcastTest(backends);
566}
567
568TEST_CASE ("GREATER_EQUAL_INT32_CpuRef_Test")
569{
570 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
571 GreaterEqualInt32Test(backends);
572}
573
574TEST_CASE ("LESS_FP32_CpuRef_Test")
575{
576 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
577 LessFP32Test(backends);
578}
579
580TEST_CASE ("LESS_Broadcast_CpuRef_Test")
581{
582 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
583 LessBroadcastTest(backends);
584}
585
586TEST_CASE ("LESS_INT32_CpuRef_Test")
587{
588 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
589 LessInt32Test(backends);
590}
591
592TEST_CASE ("LESS_EQUAL_FP32_CpuRef_Test")
593{
594 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
595 LessEqualFP32Test(backends);
596}
597
598TEST_CASE ("LESS_EQUAL_Broadcast_CpuRef_Test")
599{
600 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
601 LessEqualBroadcastTest(backends);
602}
603
604TEST_CASE ("LESS_EQUAL_INT32_CpuRef_Test")
605{
606 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
607 LessEqualInt32Test(backends);
608}
609} // End TEST_SUITE("Comparison_CpuRefTests")
610
611
612
613TEST_SUITE("Comparison_GpuAccTests")
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]614{
615
616TEST_CASE ("EQUAL_FP32_GpuAcc_Test")
617{
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]618 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]619 EqualFP32Test(backends);
620}
621
622TEST_CASE ("EQUAL_Broadcast_GpuAcc_Test")
623{
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]624 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]625 EqualBroadcastTest(backends);
626}
627
628TEST_CASE ("EQUAL_INT32_GpuAcc_Test")
629{
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]630 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]631 EqualInt32Test(backends);
632}
633
634TEST_CASE ("NOT_EQUAL_FP32_GpuAcc_Test")
635{
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]636 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]637 NotEqualFP32Test(backends);
638}
639
640TEST_CASE ("NOT_EQUAL_Broadcast_GpuAcc_Test")
641{
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]642 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]643 NotEqualBroadcastTest(backends);
644}
645
646TEST_CASE ("NOT_EQUAL_INT32_GpuAcc_Test")
647{
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]648 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]649 NotEqualInt32Test(backends);
650}
651
652TEST_CASE ("GREATER_FP32_GpuAcc_Test")
653{
654 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
655 armnn::Compute::CpuRef };
656 GreaterFP32Test(backends);
657}
658
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]659TEST_CASE ("GREATER_Broadcast_GpuAcc_Test")
660{
661 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
662 armnn::Compute::CpuRef };
663 GreaterBroadcastTest(backends);
664}
665
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]666TEST_CASE ("GREATER_INT32_GpuAcc_Test")
667{
668 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
669 armnn::Compute::CpuRef };
670 GreaterInt32Test(backends);
671}
672
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]673TEST_CASE ("GREATER_EQUAL_FP32_GpuAcc_Test")
674{
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]675 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]676 GreaterEqualFP32Test(backends);
677}
678
679TEST_CASE ("GREATER_EQUAL_Broadcast_GpuAcc_Test")
680{
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]681 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]682 GreaterEqualBroadcastTest(backends);
683}
684
685TEST_CASE ("GREATER_EQUAL_INT32_GpuAcc_Test")
686{
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]687 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]688 GreaterEqualInt32Test(backends);
689}
690
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]691TEST_CASE ("LESS_FP32_GpuAcc_Test")
692{
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]693 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]694 LessFP32Test(backends);
695}
696
697TEST_CASE ("LESS_Broadcast_GpuAcc_Test")
698{
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]699 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]700 LessBroadcastTest(backends);
701}
702
703TEST_CASE ("LESS_INT32_GpuAcc_Test")
704{
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]705 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]706 LessInt32Test(backends);
707}
708
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]709TEST_CASE ("LESS_EQUAL_FP32_GpuAcc_Test")
710{
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]711 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]712 LessEqualFP32Test(backends);
713}
714
715TEST_CASE ("LESS_EQUAL_Broadcast_GpuAcc_Test")
716{
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]717 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]718 LessEqualBroadcastTest(backends);
719}
720
721TEST_CASE ("LESS_EQUAL_INT32_GpuAcc_Test")
722{
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]723 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]724 LessEqualInt32Test(backends);
725}
726
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]727} // End TEST_SUITE("Comparison_GpuAccTests")
728
729
730TEST_SUITE("Comparison_CpuAccTests")
731{
732
733TEST_CASE ("EQUAL_FP32_CpuAcc_Test")
734{
735 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
736 EqualFP32Test(backends);
737}
738
739TEST_CASE ("EQUAL_Broadcast_CpuAcc_Test")
740{
741 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
742 EqualBroadcastTest(backends);
743}
744
745TEST_CASE ("EQUAL_INT32_CpuAcc_Test")
746{
747 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
748 EqualInt32Test(backends);
749}
750
751TEST_CASE ("NOT_EQUAL_FP32_CpuAcc_Test")
752{
753 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
754 NotEqualFP32Test(backends);
755}
756
757TEST_CASE ("NOT_EQUAL_Broadcast_CpuAcc_Test")
758{
759 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
760 NotEqualBroadcastTest(backends);
761}
762
763TEST_CASE ("NOT_EQUAL_INT32_CpuAcc_Test")
764{
765 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
766 NotEqualInt32Test(backends);
767}
768
769TEST_CASE ("GREATER_FP32_CpuAcc_Test")
770{
771 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
772 GreaterFP32Test(backends);
773}
774
775TEST_CASE ("GREATER_Broadcast_CpuAcc_Test")
776{
777 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
778 GreaterBroadcastTest(backends);
779}
780
781TEST_CASE ("GREATER_INT32_CpuAcc_Test")
782{
783 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
784 GreaterInt32Test(backends);
785}
786
787TEST_CASE ("GREATER_EQUAL_FP32_CpuAcc_Test")
788{
789 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
790 GreaterEqualFP32Test(backends);
791}
792
793TEST_CASE ("GREATER_EQUAL_Broadcast_CpuAcc_Test")
794{
795 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
796 GreaterEqualBroadcastTest(backends);
797}
798
799TEST_CASE ("GREATER_EQUAL_INT32_CpuAcc_Test")
800{
801 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
802 GreaterEqualInt32Test(backends);
803}
804
805TEST_CASE ("LESS_FP32_CpuAcc_Test")
806{
807 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
808 LessFP32Test(backends);
809}
810
811TEST_CASE ("LESS_Broadcast_CpuAcc_Test")
812{
813 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
814 LessBroadcastTest(backends);
815}
816
817TEST_CASE ("LESS_INT32_CpuAcc_Test")
818{
819 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
820 LessInt32Test(backends);
821}
822
823TEST_CASE ("LESS_EQUAL_FP32_CpuAcc_Test")
824{
825 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
826 LessEqualFP32Test(backends);
827}
828
829TEST_CASE ("LESS_EQUAL_Broadcast_CpuAcc_Test")
830{
831 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
832 LessEqualBroadcastTest(backends);
833}
834
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]835TEST_CASE ("LESS_EQUAL_INT32_CpuAcc_Test")
836{
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]837 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]838 LessEqualInt32Test(backends);
839}
840
Jan Eilersfe73b042020-11-18 10:36:46 +0000[diff] [blame]841} // End TEST_SUITE("Comparison_CpuAccTests")
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame]842
843} // namespace armnnDelegate