Add implementation for Boolean Operator blocks: AndConst, Not, Or, and Xor with corresponding tests.

Update CMakeLists to include new tests for these blocks.

Author: alexhojinpark

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

@@ -0,0 +1,37 @@
+#ifndef ANDCONST_HPP
+#define ANDCONST_HPP
+
+#include <concepts>
+#include <gnuradio-4.0/Block.hpp>
+#include <gnuradio-4.0/BlockRegistry.hpp>
+
+namespace gr::basic {
+
+GR_REGISTER_BLOCK(gr::basic::AndConst, [ uint8_t, int16_t, int32_t])
+
+template<std::integral T>
+struct AndConst : Block<AndConst <T>> {
+    using Description = Doc<"@brief Performs a bitwise AND operation on two inputs, producing one output stream.">;
+
+    PortIn<T> in;
+    PortOut<T> out;
+
+    T constant = 1;
+
+    GR_MAKE_REFLECTABLE(AndConst, in, out, constant);
+
+    [[nodiscard]] constexpr T processOne(T input) const noexcept { return input & constant; }
+
+    // Validate constant value (restrict to 0 or 1)
+    void settingsChanged(const property_map& /* old_settings */, const property_map& new_settings) {
+        if (new_settings.contains("constant")) {
+            if (constant != 0 && constant != 1) {
+                throw std::runtime_error("Constant must be 0 or 1.");
+            }
+        }
+    }
+};
+
+} // namespace gr::basic
+
+#endif // ANDCONST_HPP

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

@@ -0,0 +1,26 @@
+#ifndef NOT_HPP
+#define NOT_HPP
+
+#include <concepts>
+#include <gnuradio-4.0/Block.hpp>
+#include <gnuradio-4.0/BlockRegistry.hpp>
+
+namespace gr::basic {
+
+GR_REGISTER_BLOCK(gr::basic::Not, [ uint8_t, int16_t, int32_t])
+
+template<std::integral T>
+struct Not : Block<Not<T>> {
+    using Description = Doc<"@brief Performs a bitwise NOT operation on the input stream, producing an output stream with inverted bits.">;
+
+    PortIn<T> in;
+    PortOut<T> out;
+
+    GR_MAKE_REFLECTABLE(Not, in, out);
+
+    [[nodiscard]] constexpr T processOne(T input) const noexcept { return ~input; }
+};
+
+} // namespace gr::basic
+
+#endif // NOT_HPP

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

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

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

@@ -0,0 +1,28 @@
+#ifndef XOR_HPP
+#define XOR_HPP
+
+#include <concepts>
+#include <gnuradio-4.0/Block.hpp>
+#include <gnuradio-4.0/BlockRegistry.hpp>
+
+namespace gr::basic {
+
+GR_REGISTER_BLOCK(gr::basic::Xor, [ uint8_t, int16_t, int32_t ])
+
+template<std::integral T>
+struct Xor : Block<Xor<T>> {
+    using Description = Doc<"@brief Performs a bitwise XOR operation on two input streams, producing one output stream.">;
+
+    PortIn<T>  in1;
+    PortIn<T>  in2;
+    PortOut<T> out;
+
+    GR_MAKE_REFLECTABLE(Xor, in1, in2, out);
+
+    [[nodiscard]] constexpr T processOne(T input1, T input2) const noexcept { return input1 ^ input2; }
+
+};
+
+} // namespace gr::basic
+
+#endif // XOR_HPP

blocks/basic/test/CMakeLists.txt

@@ -4,10 +4,10 @@ add_ut_test(qa_sources)
 add_ut_test(qa_DataSink)
 add_ut_test(qa_TriggerBlocks)
 add_ut_test(qa_And)
-# add_ut_test(qa_AndConst)
-# add_ut_test(qa_Not)
-# add_ut_test(qa_Or)
-# add_ut_test(qa_Xor)
+add_ut_test(qa_AndConst)
+add_ut_test(qa_Not)
+add_ut_test(qa_Or)
+add_ut_test(qa_Xor)
 
 
 if(GR_ENABLE_BLOCK_REGISTRY AND INTERNAL_ENABLE_BLOCK_PLUGINS)

blocks/basic/test/qa_AndConst.cpp

@@ -0,0 +1,57 @@
+#include <boost/ut.hpp>
+#include <gnuradio-4.0/basic/AndConst.hpp>
+
+using namespace gr::basic;
+using namespace boost::ut;
+
+const suite AndConstTests = [] {
+    "uint8_t support"_test = [] {
+        AndConst<uint8_t> andConstBlock;
+
+        // Test default constant = 1
+        andConstBlock.constant = 1;
+        expect(eq(andConstBlock.processOne(0xFF), 0x01));
+        expect(eq(andConstBlock.processOne(0x00), 0x00));
+        expect(eq(andConstBlock.processOne(0xAA), 0x00));
+
+        // Test constant = 0
+        andConstBlock.constant = 0;
+        expect(eq(andConstBlock.processOne(0xFF), 0x00));
+        expect(eq(andConstBlock.processOne(0x00), 0x00));
+        expect(eq(andConstBlock.processOne(0xAA), 0x00));
+    };
+
+    "int16_t support"_test = [] {
+        AndConst<int16_t> andConstBlock;
+
+        // Test default constant = 1
+        andConstBlock.constant = 1;
+        expect(eq(andConstBlock.processOne(static_cast<int16_t>(0xFF)), 0x0001));
+        expect(eq(andConstBlock.processOne(static_cast<int16_t>(0x00)), 0x0000));
+        expect(eq(andConstBlock.processOne(static_cast<int16_t>(0xAA)), 0x0000));
+
+        // Test constant = 0
+        andConstBlock.constant = 0;
+        expect(eq(andConstBlock.processOne(static_cast<int16_t>(0xFF)), 0x0000));
+        expect(eq(andConstBlock.processOne(static_cast<int16_t>(0x00)), 0x0000));
+        expect(eq(andConstBlock.processOne(static_cast<int16_t>(0xAA)), 0x0000));
+    };
+
+    "int32_t support"_test = [] {
+        AndConst<int32_t> andConstBlock;
+
+        // Test default constant = 1
+        andConstBlock.constant = 1;
+        expect(eq(andConstBlock.processOne((0xFF)), 0x00000001));
+        expect(eq(andConstBlock.processOne((0x00)), 0x00000000));
+        expect(eq(andConstBlock.processOne((0xAA)), 0x00000000));
+
+        // Test constant = 0
+        andConstBlock.constant = 0;
+        expect(eq(andConstBlock.processOne((0xFF)), 0x00000000));
+        expect(eq(andConstBlock.processOne((0x00)), 0x00000000));
+        expect(eq(andConstBlock.processOne((0xAA)), 0x00000000));
+    };
+};
+
+int main() { return boost::ut::cfg<boost::ut::override>.run(); }

blocks/basic/test/qa_Not.cpp

@@ -0,0 +1,35 @@
+#include <boost/ut.hpp>
+#include <gnuradio-4.0/basic/Not.hpp>
+
+using namespace gr::basic;
+using namespace boost::ut;
+
+const suite NotTests = [] {
+    "uint8_t support"_test = [] {
+        Not<uint8_t> notBlock;
+
+        expect(eq(notBlock.processOne(0xFF), 0x00));
+        expect(eq(notBlock.processOne(0x00), 0xFF));
+        expect(eq(notBlock.processOne(0xAA), 0x55)); // ~(10101010) = 01010101
+    };
+
+    "int16_t support"_test = [] {
+        Not<int16_t> notBlock;
+
+        expect(eq(notBlock.processOne(static_cast<int16_t>(0x00FF)), static_cast<int16_t>(0xFF00)));
+        expect(eq(notBlock.processOne(static_cast<int16_t>(0x0000)), static_cast<int16_t>(0xFFFF)));
+        expect(eq(notBlock.processOne(static_cast<int16_t>(0xAAAA)), static_cast<int16_t>(0x5555)));
+    };
+
+
+    "int32_t support"_test = [] {
+        Not<int32_t> notBlock;
+
+        expect(eq(notBlock.processOne(0x000000FF), static_cast<int32_t>(0xFFFFFF00)));
+        expect(eq(notBlock.processOne(0x00000000), static_cast<int32_t>(0xFFFFFFFF)));
+        expect(eq(notBlock.processOne(0x0000AAAA), static_cast<int32_t>(0xFFFF5555)));
+    };
+};
+
+
+int main() { return boost::ut::cfg<boost::ut::override>.run(); }

blocks/basic/test/qa_Or.cpp

@@ -0,0 +1,33 @@
+#include <boost/ut.hpp>
+#include <gnuradio-4.0/basic/Or.hpp>
+
+using namespace gr::basic;
+using namespace boost::ut;
+
+const suite OrTests = [] {
+    "uint8_t support"_test = [] {
+        Or<uint8_t> orBlock;
+
+        expect(eq(orBlock.processOne(0xAA, 0x55), 0xFF));
+        expect(eq(orBlock.processOne(0x00, 0xFF), 0xFF));
+        expect(eq(orBlock.processOne(0x01, 0x02), 0x03)); // 1 | 2 = 3
+    };
+
+    "int16_t support"_test = [] {
+        Or<int16_t> orBlock;
+
+        expect(eq(orBlock.processOne(static_cast<int16_t>(0x00AA), static_cast<int16_t>(0x0055)), static_cast<int16_t>(0x00FF)));
+        expect(eq(orBlock.processOne(static_cast<int16_t>(0x0000), static_cast<int16_t>(0xFFFF)), static_cast<int16_t>(0xFFFF)));
+        expect(eq(orBlock.processOne(static_cast<int16_t>(0xAAAA), static_cast<int16_t>(0x5555)), static_cast<int16_t>(0xFFFF)));
+    };
+
+    "int32_t support"_test = [] {
+        Or<int32_t> orBlock;
+
+        expect(eq(orBlock.processOne(0x000000AA, 0x00000055), 0x000000FF));
+        expect(eq(orBlock.processOne(0x00000000, 0x0000FFFF), 0x0000FFFF));
+        expect(eq(orBlock.processOne(0x0000AAAA, 0x00005555), 0x0000FFFF));
+    };
+};
+
+int main() { return boost::ut::cfg<boost::ut::override>.run(); }

blocks/basic/test/qa_Xor.cpp

@@ -0,0 +1,33 @@
+#include <boost/ut.hpp>
+#include <gnuradio-4.0/basic/Xor.hpp>
+
+using namespace gr::basic;
+using namespace boost::ut;
+
+const suite XorTests = [] {
+    "uint8_t support"_test = [] {
+        Xor<uint8_t> xorBlock;
+
+        expect(eq(xorBlock.processOne(0xAA, 0x55), 0xFF));
+        expect(eq(xorBlock.processOne(0xFF, 0xFF), 0x00));
+        expect(eq(xorBlock.processOne(0x01, 0x03), 0x02)); // 1 ^ 2 = 3
+    };
+
+    "int16_t support"_test = [] {
+        Xor<int16_t> xorBlock;
+
+        expect(eq(xorBlock.processOne(static_cast<int16_t>(0x00AA), static_cast<int16_t>(0x0055)), static_cast<int16_t>(0x00FF)));
+        expect(eq(xorBlock.processOne(static_cast<int16_t>(0xAAAA), static_cast<int16_t>(0xAAAA)), static_cast<int16_t>(0x0000)));
+        expect(eq(xorBlock.processOne(static_cast<int16_t>(0x0F0F), static_cast<int16_t>(0xF0F0)), static_cast<int16_t>(0xFFFF)));
+    };
+
+    "int32_t support"_test = [] {
+        Xor<int32_t> xorBlock;
+
+        expect(eq(xorBlock.processOne(0x000000AA, 0x00000055), 0x000000FF));
+        expect(eq(xorBlock.processOne(0x0000AAAA, 0x0000AAAA), 0x00000000));
+        expect(eq(xorBlock.processOne(0x00000F0F, 0x0000F0F0), 0x0000FFFF));
+    };
+};
+
+int main() { return boost::ut::cfg<boost::ut::override>.run(); }