Add templated bitwise AND block with tests (refs #161)

Author: alexhojinpark

blocks/basic/CMakeLists.txt

@@ -12,7 +12,8 @@ add_library(
   include/gnuradio-4.0/basic/SignalGenerator.hpp
   include/gnuradio-4.0/basic/StreamToDataSet.hpp
   include/gnuradio-4.0/basic/SyncBlock.hpp
-  include/gnuradio-4.0/basic/Trigger.hpp)
+  include/gnuradio-4.0/basic/Trigger.hpp
+  include/gnuradio-4.0/basic/And.hpp)
 target_link_libraries(gr-basic INTERFACE gnuradio-core gnuradio-algorithm)
 target_include_directories(gr-basic INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include/>
                                               $<INSTALL_INTERFACE:include/>)

blocks/basic/include/gnuradio-4.0/basic/And.hpp

@@ -0,0 +1,29 @@
+#ifndef AND_HPP
+#define AND_HPP
+
+#include <gnuradio-4.0/Block.hpp>
+#include <gnuradio-4.0/BlockRegistry.hpp>
+
+namespace gr::basic {
+
+GR_REGISTER_BLOCK(gr::basic::And, [uint8_t, int16_t, int32_t])
+
+template<typename T>
+requires std::is_arithmetic_v<T>
+struct And : Block<And<T>> {
+    using Description = Doc<"@brief Performs a bitwise AND operation on two inputs, producing one output stream.">;
+    
+    PortIn<T> in1;
+    PortIn<T> in2;
+    PortOut<T> out;
+
+    GR_MAKE_REFLECTABLE(And, in1, in2, out);
+
+    [[nodiscard]] constexpr T processOne(T input1, T input2) const noexcept {
+        return input1 & input2;
+    }
+};
+
+} // namespace gr::blocks
+
+#endif // AND_HPP

blocks/basic/test/CMakeLists.txt

@@ -3,6 +3,7 @@ add_ut_test(qa_Selector)
 add_ut_test(qa_sources)
 add_ut_test(qa_DataSink)
 add_ut_test(qa_TriggerBlocks)
+add_ut_test(qa_And)
 
 if(ENABLE_BLOCK_REGISTRY AND ENABLE_BLOCK_PLUGINS)
   add_ut_test(qa_BasicKnownBlocks)

blocks/basic/test/qa_And.cpp

@@ -0,0 +1,61 @@
+#include <boost/ut.hpp>
+#include <gnuradio-4.0/basic/And.hpp>
+// #include <limits>
+
+using namespace gr::basic;
+using namespace boost::ut;
+
+const suite AndTests = [] {
+    "Bitwise AND operations"_test = [] {
+        And<uint8_t> andBlock;
+        // Basic bitwise AND operation
+        expect(eq(andBlock.processOne(0xFF, 0x0F), 0x0F));  // 0xFF & 0x0F = 0x0F
+        expect(eq(andBlock.processOne(0x00, 0xFF), 0x00));
+        expect(eq(andBlock.processOne(0xAB, 0x22), 0x22));
+    };
+
+    "Edge cases"_test = [] {
+        And<uint8_t> andBlock;
+        // Edge cases for boundary values (max and min values)
+        expect(eq(andBlock.processOne(0xFF, 0xFF), 0xFF));  // 0xFF & 0xFF = 0xFF
+        expect(eq(andBlock.processOne(0x00, 0x00), 0x00));  // 0x00 & 0x00 = 0x00
+    };
+
+    "int16_t support"_test = [] {
+        And<int16_t> andBlock;
+        // Test with int16_t values
+        expect(eq(andBlock.processOne(0x7FFF, 0x00FF), 0x00FF));  // 0x7FFF & 0x00FF = 0x0101
+        expect(eq(andBlock.processOne(static_cast<int16_t>(-1), static_cast<int16_t>(0xAABB)), static_cast<int16_t>(0xAABB))); // -1 & 0xAABB = 0xAABB
+    };
+
+     "int32_t support"_test = [] {
+        And<int32_t> andBlock;
+        // Test bitwise AND on int32_t values (max and min values)
+        expect(eq(andBlock.processOne(0xFFFF, 0x0F0F), 0x0F0F));  // 0xFFFF (1111111111111111) & 0x0F0F (0000111100001111) = 0x0F0F
+        expect(eq(andBlock.processOne(-1, 0x0000), 0x0000));  // -1 & 0x0000 = 0x0000
+    };
+
+    "Boundary cases"_test = [] {
+        And<int32_t> andBlock;
+        // Boundary test cases for int32_t limits
+        expect(eq(andBlock.processOne(std::numeric_limits<int32_t>::max(), std::numeric_limits<int32_t>::min()), 0));  // MAX & MIN = 0
+        expect(eq(andBlock.processOne(std::numeric_limits<int32_t>::max(), -1), std::numeric_limits<int32_t>::max()));  // MAX & -1 = MAX
+    };
+
+    "Negative values"_test = [] {
+        And<int16_t> andBlock;
+        // Test with negative values for int16_t
+        expect(eq(andBlock.processOne(static_cast<int16_t>(-1), static_cast<int16_t>(-1)), static_cast<int16_t>(-1)));  // -1 & -1 = -1
+
+        /*
+              1111 1111 1111 1011   (-5 in two's complement)
+            & 0000 0000 0000 0011   (3 in binary)
+            --------------------
+            0000 0000 0000 0011   (Result = 3)
+         */
+        expect(eq(andBlock.processOne(static_cast<int16_t>(-5), static_cast<int16_t>(3)), static_cast<int16_t>(3)));  // -5 & 3 = 3
+
+    };
+};
+
+int main() { return boost::ut::cfg<boost::ut::override>.run(); }