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