1 //
2 // Copyright © 2020, 2023 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 <schema_generated.h>
15 #include <tensorflow/lite/version.h>
16
17 #include <doctest/doctest.h>
18
19 namespace armnnDelegate
20 {
21
EqualFP32Test(std::vector<armnn::BackendId> & backends)22 void 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
EqualBroadcastTest(std::vector<armnn::BackendId> & backends)58 void 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
EqualInt32Test(std::vector<armnn::BackendId> & backends)87 void 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
NotEqualFP32Test(std::vector<armnn::BackendId> & backends)110 void 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
NotEqualBroadcastTest(std::vector<armnn::BackendId> & backends)145 void 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
NotEqualInt32Test(std::vector<armnn::BackendId> & backends)174 void 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
GreaterFP32Test(std::vector<armnn::BackendId> & backends)197 void 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
GreaterBroadcastTest(std::vector<armnn::BackendId> & backends)220 void 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
GreaterInt32Test(std::vector<armnn::BackendId> & backends)249 void 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
GreaterEqualFP32Test(std::vector<armnn::BackendId> & backends)272 void 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
GreaterEqualBroadcastTest(std::vector<armnn::BackendId> & backends)295 void 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
GreaterEqualInt32Test(std::vector<armnn::BackendId> & backends)325 void 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
LessFP32Test(std::vector<armnn::BackendId> & backends)348 void 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
LessBroadcastTest(std::vector<armnn::BackendId> & backends)371 void 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
LessInt32Test(std::vector<armnn::BackendId> & backends)401 void 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
LessEqualFP32Test(std::vector<armnn::BackendId> & backends)424 void 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
LessEqualBroadcastTest(std::vector<armnn::BackendId> & backends)447 void 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
LessEqualInt32Test(std::vector<armnn::BackendId> & backends)477 void 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
500 TEST_SUITE("Comparison_CpuRefTests")
501 {
502
503 TEST_CASE ("EQUAL_FP32_CpuRef_Test")
504 {
505 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
506 EqualFP32Test(backends);
507 }
508
509 TEST_CASE ("EQUAL_Broadcast_CpuRef_Test")
510 {
511 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
512 EqualBroadcastTest(backends);
513 }
514
515 TEST_CASE ("EQUAL_INT32_CpuRef_Test")
516 {
517 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
518 EqualInt32Test(backends);
519 }
520
521 TEST_CASE ("NOT_EQUAL_FP32_CpuRef_Test")
522 {
523 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
524 NotEqualFP32Test(backends);
525 }
526
527 TEST_CASE ("NOT_EQUAL_Broadcast_CpuRef_Test")
528 {
529 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
530 NotEqualBroadcastTest(backends);
531 }
532
533 TEST_CASE ("NOT_EQUAL_INT32_CpuRef_Test")
534 {
535 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
536 NotEqualInt32Test(backends);
537 }
538
539 TEST_CASE ("GREATER_FP32_CpuRef_Test")
540 {
541 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
542 GreaterFP32Test(backends);
543 }
544
545 TEST_CASE ("GREATER_Broadcast_CpuRef_Test")
546 {
547 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
548 GreaterBroadcastTest(backends);
549 }
550
551 TEST_CASE ("GREATER_INT32_CpuRef_Test")
552 {
553 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
554 GreaterInt32Test(backends);
555 }
556
557 TEST_CASE ("GREATER_EQUAL_FP32_CpuRef_Test")
558 {
559 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
560 GreaterEqualFP32Test(backends);
561 }
562
563 TEST_CASE ("GREATER_EQUAL_Broadcast_CpuRef_Test")
564 {
565 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
566 GreaterEqualBroadcastTest(backends);
567 }
568
569 TEST_CASE ("GREATER_EQUAL_INT32_CpuRef_Test")
570 {
571 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
572 GreaterEqualInt32Test(backends);
573 }
574
575 TEST_CASE ("LESS_FP32_CpuRef_Test")
576 {
577 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
578 LessFP32Test(backends);
579 }
580
581 TEST_CASE ("LESS_Broadcast_CpuRef_Test")
582 {
583 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
584 LessBroadcastTest(backends);
585 }
586
587 TEST_CASE ("LESS_INT32_CpuRef_Test")
588 {
589 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
590 LessInt32Test(backends);
591 }
592
593 TEST_CASE ("LESS_EQUAL_FP32_CpuRef_Test")
594 {
595 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
596 LessEqualFP32Test(backends);
597 }
598
599 TEST_CASE ("LESS_EQUAL_Broadcast_CpuRef_Test")
600 {
601 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
602 LessEqualBroadcastTest(backends);
603 }
604
605 TEST_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
614 TEST_SUITE("Comparison_GpuAccTests")
615 {
616
617 TEST_CASE ("EQUAL_FP32_GpuAcc_Test")
618 {
619 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
620 EqualFP32Test(backends);
621 }
622
623 TEST_CASE ("EQUAL_Broadcast_GpuAcc_Test")
624 {
625 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
626 EqualBroadcastTest(backends);
627 }
628
629 TEST_CASE ("EQUAL_INT32_GpuAcc_Test")
630 {
631 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
632 EqualInt32Test(backends);
633 }
634
635 TEST_CASE ("NOT_EQUAL_FP32_GpuAcc_Test")
636 {
637 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
638 NotEqualFP32Test(backends);
639 }
640
641 TEST_CASE ("NOT_EQUAL_Broadcast_GpuAcc_Test")
642 {
643 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
644 NotEqualBroadcastTest(backends);
645 }
646
647 TEST_CASE ("NOT_EQUAL_INT32_GpuAcc_Test")
648 {
649 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
650 NotEqualInt32Test(backends);
651 }
652
653 TEST_CASE ("GREATER_FP32_GpuAcc_Test")
654 {
655 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
656 armnn::Compute::CpuRef };
657 GreaterFP32Test(backends);
658 }
659
660 TEST_CASE ("GREATER_Broadcast_GpuAcc_Test")
661 {
662 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
663 armnn::Compute::CpuRef };
664 GreaterBroadcastTest(backends);
665 }
666
667 TEST_CASE ("GREATER_INT32_GpuAcc_Test")
668 {
669 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc,
670 armnn::Compute::CpuRef };
671 GreaterInt32Test(backends);
672 }
673
674 TEST_CASE ("GREATER_EQUAL_FP32_GpuAcc_Test")
675 {
676 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
677 GreaterEqualFP32Test(backends);
678 }
679
680 TEST_CASE ("GREATER_EQUAL_Broadcast_GpuAcc_Test")
681 {
682 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
683 GreaterEqualBroadcastTest(backends);
684 }
685
686 TEST_CASE ("GREATER_EQUAL_INT32_GpuAcc_Test")
687 {
688 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
689 GreaterEqualInt32Test(backends);
690 }
691
692 TEST_CASE ("LESS_FP32_GpuAcc_Test")
693 {
694 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
695 LessFP32Test(backends);
696 }
697
698 TEST_CASE ("LESS_Broadcast_GpuAcc_Test")
699 {
700 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
701 LessBroadcastTest(backends);
702 }
703
704 TEST_CASE ("LESS_INT32_GpuAcc_Test")
705 {
706 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
707 LessInt32Test(backends);
708 }
709
710 TEST_CASE ("LESS_EQUAL_FP32_GpuAcc_Test")
711 {
712 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
713 LessEqualFP32Test(backends);
714 }
715
716 TEST_CASE ("LESS_EQUAL_Broadcast_GpuAcc_Test")
717 {
718 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
719 LessEqualBroadcastTest(backends);
720 }
721
722 TEST_CASE ("LESS_EQUAL_INT32_GpuAcc_Test")
723 {
724 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
725 LessEqualInt32Test(backends);
726 }
727
728 } // End TEST_SUITE("Comparison_GpuAccTests")
729
730
731 TEST_SUITE("Comparison_CpuAccTests")
732 {
733
734 TEST_CASE ("EQUAL_FP32_CpuAcc_Test")
735 {
736 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
737 EqualFP32Test(backends);
738 }
739
740 TEST_CASE ("EQUAL_Broadcast_CpuAcc_Test")
741 {
742 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
743 EqualBroadcastTest(backends);
744 }
745
746 TEST_CASE ("EQUAL_INT32_CpuAcc_Test")
747 {
748 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
749 EqualInt32Test(backends);
750 }
751
752 TEST_CASE ("NOT_EQUAL_FP32_CpuAcc_Test")
753 {
754 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
755 NotEqualFP32Test(backends);
756 }
757
758 TEST_CASE ("NOT_EQUAL_Broadcast_CpuAcc_Test")
759 {
760 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
761 NotEqualBroadcastTest(backends);
762 }
763
764 TEST_CASE ("NOT_EQUAL_INT32_CpuAcc_Test")
765 {
766 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
767 NotEqualInt32Test(backends);
768 }
769
770 TEST_CASE ("GREATER_FP32_CpuAcc_Test")
771 {
772 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
773 GreaterFP32Test(backends);
774 }
775
776 TEST_CASE ("GREATER_Broadcast_CpuAcc_Test")
777 {
778 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
779 GreaterBroadcastTest(backends);
780 }
781
782 TEST_CASE ("GREATER_INT32_CpuAcc_Test")
783 {
784 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
785 GreaterInt32Test(backends);
786 }
787
788 TEST_CASE ("GREATER_EQUAL_FP32_CpuAcc_Test")
789 {
790 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
791 GreaterEqualFP32Test(backends);
792 }
793
794 TEST_CASE ("GREATER_EQUAL_Broadcast_CpuAcc_Test")
795 {
796 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
797 GreaterEqualBroadcastTest(backends);
798 }
799
800 TEST_CASE ("GREATER_EQUAL_INT32_CpuAcc_Test")
801 {
802 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
803 GreaterEqualInt32Test(backends);
804 }
805
806 TEST_CASE ("LESS_FP32_CpuAcc_Test")
807 {
808 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
809 LessFP32Test(backends);
810 }
811
812 TEST_CASE ("LESS_Broadcast_CpuAcc_Test")
813 {
814 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
815 LessBroadcastTest(backends);
816 }
817
818 TEST_CASE ("LESS_INT32_CpuAcc_Test")
819 {
820 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
821 LessInt32Test(backends);
822 }
823
824 TEST_CASE ("LESS_EQUAL_FP32_CpuAcc_Test")
825 {
826 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
827 LessEqualFP32Test(backends);
828 }
829
830 TEST_CASE ("LESS_EQUAL_Broadcast_CpuAcc_Test")
831 {
832 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
833 LessEqualBroadcastTest(backends);
834 }
835
836 TEST_CASE ("LESS_EQUAL_INT32_CpuAcc_Test")
837 {
838 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
839 LessEqualInt32Test(backends);
840 }
841
842 } // End TEST_SUITE("Comparison_CpuAccTests")
843
844 } // namespace armnnDelegate