From 7ff6b44c3dcad09d93321a13f0f6915a0f67b10d Mon Sep 17 00:00:00 2001
From: Denes Tarjan <denes.tarjan@arm.com>
Date: Mon, 8 Jan 2024 17:25:45 +0100
Subject: [PATCH] [test] Implement testing of count_nonzeros_u8

---
 intrinsiccv/include/intrinsiccv.h |   9 +++
 test/api/test_count_nonzeros.cpp  | 111 ++++++++++++++++++++++++++++++
 2 files changed, 120 insertions(+)
 create mode 100644 test/api/test_count_nonzeros.cpp

diff --git a/intrinsiccv/include/intrinsiccv.h b/intrinsiccv/include/intrinsiccv.h
index 70bbea626..64c751c6f 100644
--- a/intrinsiccv/include/intrinsiccv.h
+++ b/intrinsiccv/include/intrinsiccv.h
@@ -210,6 +210,15 @@ void INTRINSICCV_C_API(erode_u8)(const uint8_t *src, size_t src_stride,
                                  size_t height,
                                  const intrinsiccv_morphology_params_t *params);
 
+/// Counts how many nonzero elements are in the source data.
+///
+/// @param src          Pointer to the source data. Must be non-null.
+/// @param src_stride   Distance in bytes between the row first elements for
+///                     the source data. Must not be less than
+///                     width * sizeof(type).
+/// @param width        How many elements are in a row
+/// @param height       How many rows are in the data
+///
 size_t INTRINSICCV_C_API(count_nonzeros_u8)(const uint8_t *src,
                                             size_t src_stride, size_t width,
                                             size_t height);
diff --git a/test/api/test_count_nonzeros.cpp b/test/api/test_count_nonzeros.cpp
new file mode 100644
index 000000000..30bb89586
--- /dev/null
+++ b/test/api/test_count_nonzeros.cpp
@@ -0,0 +1,111 @@
+// SPDX-FileCopyrightText: 2023 Arm Limited and/or its affiliates <open-source-office@arm.com>
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <gtest/gtest.h>
+#include <intrinsiccv.h>
+
+#include <limits>
+
+#include "framework/array.h"
+#include "framework/utils.h"
+
+#define INTRINSICCV_COUNT_NONZEROS(type, suffix) \
+  INTRINSICCV_API(count_nonzeros, intrinsiccv_count_nonzeros_##suffix, type)
+
+INTRINSICCV_COUNT_NONZEROS(uint8_t, u8);
+
+template <typename ElementType>
+class TestDataAllZeros {
+ public:
+  ElementType generateInput(size_t, size_t) { return 0; }
+  size_t calculateExpected(size_t, size_t) { return 0; }
+};
+
+template <typename ElementType>
+class TestDataSomeZeros {
+ public:
+  ElementType generateInput(size_t x, size_t y) {
+    return x == y ? 0
+                  : ((y % (std::numeric_limits<ElementType>::max() - 1)) + 1);
+  }
+  size_t calculateExpected(size_t width, size_t height) {
+    return height * (width - 1);
+  }
+};
+
+template <typename ElementType>
+class TestDataAllNonZeros {
+ public:
+  ElementType generateInput(size_t x, size_t y) {
+    return ((x + y) % std::numeric_limits<ElementType>::max()) + 1;
+  }
+  size_t calculateExpected(size_t width, size_t height) {
+    return height * width;
+  }
+};
+
+template <typename ElementType, template <class> class TestDataType>
+class CountNonZerosTest {
+ public:
+  static void test(size_t src_padding) {
+    // Add enough elements to test against overflow
+    // to make sure block_finished() works as expected
+    // That means more than std::max<ElementType> * vector_length() elements
+    // Our generator (for some_zeros case) will add one 0 per line, so we will
+    // need std::max<ElementType> + 2 elements
+    const size_t width = (std::numeric_limits<ElementType>::max() + 2) *
+                         test::Options::vector_length();
+    const size_t height = test::Options::vector_length();
+
+    test::Array2D<ElementType> source{width, height, src_padding};
+    ASSERT_TRUE(source.valid());
+
+    TestDataType<ElementType> data_;
+
+    for (size_t i = 0; i < height; ++i) {
+      for (size_t j = 0; j < width; ++j) {
+        *source.at(i, j) = data_.generateInput(i, j);
+      }
+    }
+
+    size_t expected = data_.calculateExpected(width, height);
+    size_t actual = count_nonzeros<ElementType>()(source.data(), source.stride(),
+                                              width, height);
+    EXPECT_EQ(expected, actual);
+  }
+};
+
+using ElementTypes = ::testing::Types<uint8_t>;
+
+template <typename ElementType>
+class CountNonZeros : public testing::Test {};
+
+TYPED_TEST_SUITE(CountNonZeros, ElementTypes);
+
+TYPED_TEST(CountNonZeros, AllZeros) {
+  CountNonZerosTest<TypeParam, TestDataAllZeros>{}.test(0);
+}
+
+TYPED_TEST(CountNonZeros, AllZerosPadded) {
+  CountNonZerosTest<TypeParam, TestDataAllZeros>{}.test(
+      test::Options::vector_length());
+}
+
+TYPED_TEST(CountNonZeros, SomeZeros) {
+  CountNonZerosTest<TypeParam, TestDataSomeZeros>{}.test(0);
+}
+
+TYPED_TEST(CountNonZeros, SomeZerosPadded) {
+  CountNonZerosTest<TypeParam, TestDataSomeZeros>{}.test(
+      test::Options::vector_length());
+}
+
+TYPED_TEST(CountNonZeros, AllNonZeros) {
+  CountNonZerosTest<TypeParam, TestDataAllNonZeros>{}.test(0);
+}
+
+TYPED_TEST(CountNonZeros, AllNonZerosPadded) {
+  CountNonZerosTest<TypeParam, TestDataAllNonZeros>{}.test(
+      test::Options::vector_length());
+}
-- 
GitLab