Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / 8b9858d891439fd1b0710e5d245e2116a3b88d30 / . / delegate / src / test / ComparisonTest.cpp
blob: 0826535c8fc3414990bdfd9379a2ded09ec2e8e2 [file] [log] [blame]
Sadik Armagan8b9858d2020-11-09 08:26:22 +0000[diff] [blame^]1//
2// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
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>
14#include <tensorflow/lite/schema/schema_generated.h>
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
500TEST_SUITE("ComparisonTest")
501{
502
503TEST_CASE ("EQUAL_FP32_GpuAcc_Test")
504{
505 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
506 armnn::Compute::CpuRef };
507 EqualFP32Test(backends);
508}
509
510TEST_CASE ("EQUAL_FP32_CpuAcc_Test")
511{
512 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
513 armnn::Compute::CpuRef };
514 EqualFP32Test(backends);
515}
516
517TEST_CASE ("EQUAL_Broadcast_GpuAcc_Test")
518{
519 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
520 armnn::Compute::CpuRef };
521 EqualBroadcastTest(backends);
522}
523
524TEST_CASE ("EQUAL_Broadcast_CpuAcc_Test")
525{
526 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
527 armnn::Compute::CpuRef };
528 EqualBroadcastTest(backends);
529}
530
531TEST_CASE ("EQUAL_INT32_GpuAcc_Test")
532{
533 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
534 armnn::Compute::CpuRef };
535 EqualInt32Test(backends);
536}
537
538TEST_CASE ("EQUAL_INT32_CpuAcc_Test")
539{
540 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
541 armnn::Compute::CpuRef };
542 EqualInt32Test(backends);
543}
544
545TEST_CASE ("NOT_EQUAL_FP32_GpuAcc_Test")
546{
547 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
548 armnn::Compute::CpuRef };
549 NotEqualFP32Test(backends);
550}
551
552TEST_CASE ("NOT_EQUAL_FP32_CpuAcc_Test")
553{
554 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
555 armnn::Compute::CpuRef };
556 NotEqualFP32Test(backends);
557}
558
559TEST_CASE ("NOT_EQUAL_Broadcast_GpuAcc_Test")
560{
561 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
562 armnn::Compute::CpuRef };
563 NotEqualBroadcastTest(backends);
564}
565
566TEST_CASE ("NOT_EQUAL_Broadcast_CpuAcc_Test")
567{
568 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
569 armnn::Compute::CpuRef };
570 NotEqualBroadcastTest(backends);
571}
572
573TEST_CASE ("NOT_EQUAL_INT32_GpuAcc_Test")
574{
575 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
576 armnn::Compute::CpuRef };
577 NotEqualInt32Test(backends);
578}
579
580TEST_CASE ("NOT_EQUAL_INT32_CpuAcc_Test")
581{
582 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
583 armnn::Compute::CpuRef };
584 NotEqualInt32Test(backends);
585}
586
587TEST_CASE ("GREATER_FP32_GpuAcc_Test")
588{
589 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
590 armnn::Compute::CpuRef };
591 GreaterFP32Test(backends);
592}
593
594TEST_CASE ("GREATER_FP32_CpuAcc_Test")
595{
596 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
597 armnn::Compute::CpuRef };
598 GreaterFP32Test(backends);
599}
600
601TEST_CASE ("GREATER_Broadcast_GpuAcc_Test")
602{
603 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
604 armnn::Compute::CpuRef };
605 GreaterBroadcastTest(backends);
606}
607
608TEST_CASE ("GREATER_Broadcast_CpuAcc_Test")
609{
610 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
611 armnn::Compute::CpuRef };
612 GreaterBroadcastTest(backends);
613}
614
615TEST_CASE ("GREATER_INT32_GpuAcc_Test")
616{
617 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
618 armnn::Compute::CpuRef };
619 GreaterInt32Test(backends);
620}
621
622TEST_CASE ("GREATER_INT32_CpuAcc_Test")
623{
624 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
625 armnn::Compute::CpuRef };
626 GreaterInt32Test(backends);
627}
628TEST_CASE ("GREATER_EQUAL_FP32_GpuAcc_Test")
629{
630 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
631 armnn::Compute::CpuRef };
632 GreaterEqualFP32Test(backends);
633}
634
635TEST_CASE ("GREATER_EQUAL_FP32_CpuAcc_Test")
636{
637 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
638 armnn::Compute::CpuRef };
639 GreaterEqualFP32Test(backends);
640}
641
642TEST_CASE ("GREATER_EQUAL_Broadcast_GpuAcc_Test")
643{
644 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
645 armnn::Compute::CpuRef };
646 GreaterEqualBroadcastTest(backends);
647}
648
649TEST_CASE ("GREATER_EQUAL_Broadcast_CpuAcc_Test")
650{
651 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
652 armnn::Compute::CpuRef };
653 GreaterEqualBroadcastTest(backends);
654}
655
656TEST_CASE ("GREATER_EQUAL_INT32_GpuAcc_Test")
657{
658 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
659 armnn::Compute::CpuRef };
660 GreaterEqualInt32Test(backends);
661}
662
663TEST_CASE ("GREATER_EQUAL_INT32_CpuAcc_Test")
664{
665 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
666 armnn::Compute::CpuRef };
667 GreaterEqualInt32Test(backends);
668}
669TEST_CASE ("LESS_FP32_GpuAcc_Test")
670{
671 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
672 armnn::Compute::CpuRef };
673 LessFP32Test(backends);
674}
675
676TEST_CASE ("LESS_FP32_CpuAcc_Test")
677{
678 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
679 armnn::Compute::CpuRef };
680 LessFP32Test(backends);
681}
682
683TEST_CASE ("LESS_Broadcast_GpuAcc_Test")
684{
685 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
686 armnn::Compute::CpuRef };
687 LessBroadcastTest(backends);
688}
689
690TEST_CASE ("LESS_Broadcast_CpuAcc_Test")
691{
692 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
693 armnn::Compute::CpuRef };
694 LessBroadcastTest(backends);
695}
696
697TEST_CASE ("LESS_INT32_GpuAcc_Test")
698{
699 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
700 armnn::Compute::CpuRef };
701 LessInt32Test(backends);
702}
703
704TEST_CASE ("LESS_INT32_CpuAcc_Test")
705{
706 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
707 armnn::Compute::CpuRef };
708 LessInt32Test(backends);
709}
710TEST_CASE ("LESS_EQUAL_FP32_GpuAcc_Test")
711{
712 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
713 armnn::Compute::CpuRef };
714 LessEqualFP32Test(backends);
715}
716
717TEST_CASE ("LESS_EQUAL_FP32_CpuAcc_Test")
718{
719 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
720 armnn::Compute::CpuRef };
721 LessEqualFP32Test(backends);
722}
723
724TEST_CASE ("LESS_EQUAL_Broadcast_GpuAcc_Test")
725{
726 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
727 armnn::Compute::CpuRef };
728 LessEqualBroadcastTest(backends);
729}
730
731TEST_CASE ("LESS_EQUAL_Broadcast_CpuAcc_Test")
732{
733 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
734 armnn::Compute::CpuRef };
735 LessEqualBroadcastTest(backends);
736}
737
738TEST_CASE ("LESS_EQUAL_INT32_GpuAcc_Test")
739{
740 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
741 armnn::Compute::CpuRef };
742 LessEqualInt32Test(backends);
743}
744
745TEST_CASE ("LESS_EQUAL_INT32_CpuAcc_Test")
746{
747 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc,
748 armnn::Compute::CpuRef };
749 LessEqualInt32Test(backends);
750}
751
752} // End TEST_SUITE("ComparisonTest")
753
754} // namespace armnnDelegate