diff --git a/meson.build b/meson.build
index 59278b1..7424a76 100644
--- a/meson.build
+++ b/meson.build
@@ -1,5 +1,5 @@
 project('openpower-libhei', 'cpp',
-        version: '0.1', meson_version: '>=0.49.0',
+        version: '0.1', meson_version: '>=0.50.0',
         default_options: [
             'warning_level=3',
             'werror=true',
diff --git a/src/register/hei_hardware_register.cpp b/src/register/hei_hardware_register.cpp
index 7629a06..74df35f 100644
--- a/src/register/hei_hardware_register.cpp
+++ b/src/register/hei_hardware_register.cpp
@@ -12,16 +12,6 @@
 
 //------------------------------------------------------------------------------
 
-#if 0
-void HardwareRegister::setBitString(const BitString *bs)
-{
-    BitString& l_string  = accessBitString();
-    l_string.setString(*bs);
-}
-#endif
-
-//------------------------------------------------------------------------------
-
 const BitString* HardwareRegister::getBitString(const Chip& i_chip) const
 {
     // Verify this register belongs on i_chip.
diff --git a/src/register/hei_hardware_register.hpp b/src/register/hei_hardware_register.hpp
index f79191d..ee57b2a 100644
--- a/src/register/hei_hardware_register.hpp
+++ b/src/register/hei_hardware_register.hpp
@@ -145,15 +145,6 @@
     /** Function overloaded from parent Register class. */
     const BitString* getBitString(const Chip& i_chip) const;
 
-#if 0
-    /**
-     * @brief     Updates bit string contents associated with register
-     * @param     i_bs               poiner to bit string
-     * @return    Nil
-     */
-    virtual void setBitString(const BitString * i_bs) ;
-#endif
-
     /**
      * @brief  Reads a register from hardware via the user interface APIs.
      * @param  i_chip  The target chip in which this register belongs.
diff --git a/src/register/hei_operator_register.hpp b/src/register/hei_operator_register.hpp
index 02c9b1d..ce9a869 100644
--- a/src/register/hei_operator_register.hpp
+++ b/src/register/hei_operator_register.hpp
@@ -2,6 +2,23 @@
 
 #include <register/hei_register.hpp>
 
+/**
+ * @file hei_operator_register.hpp
+ *
+ * A library of useful classes used to perform logical or bitwise math on or
+ * between other registers. The classes implemented here include NotRegister,
+ * LeftShiftRegister, RightShiftRegister, AndRegister, OrRegister, and
+ * ConstantRegister.
+ *
+ * Accompanied with other Register classes and the getBitString() function, it
+ * is possible to perform operations like:
+ *
+ *      AndRegister reg{<register1>,<register2>};
+ *      result = reg.getBitString(<someChip>);
+ *
+ * This example will return a BitString containing the result of the bitwise
+ * AND operation applied to register1 and register2.
+ */
 namespace libhei
 {
 
@@ -44,6 +61,13 @@
 // Pure virtual destructor must be defined.
 inline OperatorRegister::~OperatorRegister() {}
 
+/**
+ * @brief Using getBitString(), performs a bitwise NOT operation on a register.
+ *
+ * Example:
+ *      NotRegister reg{someRegister};
+ *      result = reg.getBitString(someChip);
+ */
 class NotRegister : public OperatorRegister
 {
   public:
@@ -90,6 +114,13 @@
     Register* iv_child;
 };
 
+/**
+ * @brief Using getBitString(), performs a left shift operation on a register.
+ *
+ * Example:
+ *      LeftShiftRegister reg{someRegister1, shiftValue};
+ *      result = reg.getBitString(someChip);
+ */
 class LeftShiftRegister : public OperatorRegister
 {
   public:
@@ -140,6 +171,13 @@
     uint16_t iv_amount;
 };
 
+/**
+ * @brief Using getBitString(), performs a right shift operation on a register.
+ *
+ * Example:
+ *      RightShiftRegister reg{someRegister1, shiftValue};
+ *      result = reg.getBitString(someChip);
+ */
 class RightShiftRegister : public OperatorRegister
 {
   public:
@@ -190,6 +228,14 @@
     uint16_t iv_amount;
 };
 
+/**
+ * @brief Using getBitString(), performs a bitwise AND operation on a pair
+ *        of registers.
+ *
+ * Example:
+ *      AndRegister reg{someRegister1, someRegister2};
+ *      result = reg.getBitString(someChip);
+ */
 class AndRegister : public OperatorRegister
 {
   public:
@@ -242,6 +288,14 @@
     Register* iv_right;
 };
 
+/**
+ * @brief Using getBitString(), performs a bitwise OR operation on a pair
+ *        of registers.
+ *
+ * Example:
+ *      OrRegister reg{someRegister1, someRegister2};
+ *      result = reg.getBitString(someChip);
+ */
 class OrRegister : public OperatorRegister
 {
   public:
@@ -294,6 +348,11 @@
     Register* iv_right;
 };
 
+/**
+ * @brief Contains a constant value that can be used within any of the other
+ *        register operators. The value can be retrieved using the
+ *        getBitString() function.
+ **/
 class ConstantRegister : public OperatorRegister
 {
   public:
diff --git a/src/register/hei_register.hpp b/src/register/hei_register.hpp
index d3435a3..ff8999c 100644
--- a/src/register/hei_register.hpp
+++ b/src/register/hei_register.hpp
@@ -15,15 +15,14 @@
 creates a place where these registers can be put together like logical
 building blocks.  For example, Register makes this possible:
 
-Register * fir = new HardwareRegister(REG_ADDRESS, REG_WIDTH,
-                                      CHIP_TYPE, ACCESS_RO);
-Register * mask = new ConstantRegister(0xffffffff00000000);
-Register * fir_mask = new AndRegister(fir, mask);
+Register * mask1 = new ConstantRegister(0xffff000000000000);
+Register * mask2 = new ConstantRegister(0xffffffff00000000);
+Register * fir_mask = new AndRegister(mask1, mask2);
 const BitString * bs = fir_mask->getBitString(chip);
 
 The getBitString function (defined by each register) provides access to
 the BitString that manages each register's data.  In this example bs will
-contain the result of fir & mask.
+contain the result of mask1 & mask2.
 */
 class Register
 {
diff --git a/test/hei_operator_register_testcase.cpp b/test/hei_operator_register_testcase.cpp
new file mode 100644
index 0000000..803bd39
--- /dev/null
+++ b/test/hei_operator_register_testcase.cpp
@@ -0,0 +1,387 @@
+#include <hei_chip.hpp>
+#include <hei_includes.hpp>
+#include <register/hei_hardware_register.hpp>
+#include <register/hei_operator_register.hpp>
+#include <register/hei_register.hpp>
+
+#include <iomanip>
+#include <iostream>
+
+#define BITSTRING_BIT_WIDTH 16
+#define CONSTANT1 0x1458 // 1458
+#define CONSTANT2 0x5368 // 5468
+
+using namespace std;
+using namespace libhei;
+
+int main()
+{
+
+    Chip my_chip;
+    size_t constant1 = CONSTANT1;
+    size_t constant2 = CONSTANT2;
+
+    // Initializing two registers
+
+    cout << "\n\n\nInitializing two constant registers ";
+    cout << "(leftside & rightside):\n\n";
+
+    cout << "\nCreating BitString \"bsa\".\n";
+    BitStringBuffer bsa{BITSTRING_BIT_WIDTH};
+    cout << "Setting BitString \"bsa\" to:  ";
+    cout << "0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << uppercase << constant1 << "\n";
+    bsa.setFieldRight(0, BITSTRING_BIT_WIDTH, constant1);
+
+    cout << "\nCreating BitString \"bsb\".\n";
+    BitStringBuffer bsb{BITSTRING_BIT_WIDTH};
+    cout << "Setting BitString \"bsb\" to:  ";
+    cout << "0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << uppercase << constant2 << "\n\n";
+    bsb.setFieldRight(0, BITSTRING_BIT_WIDTH, constant2);
+
+    cout << "Creating \"leftside\" register from bsa.\n";
+    ConstantRegister leftside(bsa);
+    cout << "Creating \"rightside\" register from bsb.\n";
+    ConstantRegister rightside(bsb);
+
+    cout << "Leftside:  ";
+    cout << "0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << leftside.getBitString(my_chip)->getFieldRight(0,
+                                                          BITSTRING_BIT_WIDTH);
+
+    cout << "  Rightside:  ";
+    cout << "0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << rightside.getBitString(my_chip)->getFieldRight(0,
+                                                           BITSTRING_BIT_WIDTH);
+    cout << "\n\n";
+
+    // Basic functional tests:
+    // AND
+    cout << "Instantiating my_and_register passing in two registers:\n";
+    cout << "AndRegister my_and_register(leftside, rightside);\n";
+    AndRegister my_and_register(leftside, rightside);
+    cout << "AND result:  ";
+    cout << "0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << my_and_register.getBitString(my_chip)->getFieldRight(
+                0, BITSTRING_BIT_WIDTH)
+         << "\n\n";
+
+    // NOT
+    cout << "Instantiating my_not_register passing in my_and_register "
+         << "from above:\n";
+    cout << "NotRegister my_not_register(my_and_register);\n";
+    NotRegister my_not_register(my_and_register);
+    cout << "NOT result:               ";
+    cout << "0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << my_not_register.getBitString(my_chip)->getFieldRight(
+                0, BITSTRING_BIT_WIDTH)
+         << "\n\n";
+
+    // Left Shift
+    cout << "Instantiating my_leftshift_register passing "
+         << "in my_not_register from above and a 4 directing i"
+         << "a left shift of 4 bits:\n";
+    cout << "LeftShiftRegister my_leftshift_register(my_not_register, 4);\n";
+    LeftShiftRegister my_leftshift_register(my_not_register, 4);
+    cout << "LeftShift result:         ";
+    cout << "0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << my_leftshift_register.getBitString(my_chip)->getFieldRight(
+                0, BITSTRING_BIT_WIDTH)
+         << "\n\n";
+
+    // Right Shift
+    cout << "Instantiating my_rightshift_register passing in "
+         << "my_leftshift_register from above and a 4 directing "
+         << "a right shift of 4 bits:\n";
+    cout << "RightShiftRegister my_rightshift_register("
+         << "my_leftshift_register, 4);\n";
+    RightShiftRegister my_rightshift_register(my_leftshift_register, 4);
+    cout << "Right Shift result:         ";
+    cout << "0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << my_rightshift_register.getBitString(my_chip)->getFieldRight(
+                0, BITSTRING_BIT_WIDTH)
+         << "\n\n";
+
+    // OR
+    cout << "Instantiating my_or_register passing in my_leftshift_register"
+         << " and my_rightshift_register from above:\n";
+    cout << "OrRegister my_or_register(my_leftshift_register,"
+         << "my_rightshift_register);\n";
+    OrRegister my_or_register(my_leftshift_register, my_rightshift_register);
+    cout << "OR result:         ";
+    cout << "0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << my_or_register.getBitString(my_chip)->getFieldRight(
+                0, BITSTRING_BIT_WIDTH)
+         << "\n\n";
+
+    // = operator
+
+    // ConstantRegister
+    cout << "\nExercising operator \"=\" (assignment):\n\n";
+
+    cout << "Assigning leftside register to constreg1 register.  (";
+    ConstantRegister constreg1 = leftside;
+    cout << "0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << constreg1.getBitString(my_chip)->getFieldRight(0,
+                                                           BITSTRING_BIT_WIDTH)
+         << ")\n";
+    cout << "ConstantRegister constreg1 = leftside;\n";
+
+    cout << "Assigning rightside register to constreg2 register.  (";
+    ConstantRegister constreg2 = rightside;
+    cout << "0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << constreg2.getBitString(my_chip)->getFieldRight(0,
+                                                           BITSTRING_BIT_WIDTH)
+         << ")\n";
+    cout << "ConstantRegister constreg2 = rightside;\n";
+
+    // AndRegister
+    cout << "\nCreating and_register1 with leftside & rightside registers.\n";
+    cout << "AndRegister and_register1(leftside,rightside);\n";
+    AndRegister and_register1(leftside, rightside);
+    cout << "Creating and_register2 with the assignment operator (=).\n";
+    cout << "AndRegister and_register2 = and_register1;\n";
+    AndRegister and_register2 = and_register1;
+    cout << "and_register2 = ";
+    cout << "0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << and_register2.getBitString(my_chip)->getFieldRight(
+                0, BITSTRING_BIT_WIDTH)
+         << "\n";
+
+    // NotRegister
+    cout << "\nCreating not_register1 with leftside register.\n";
+    cout << "NotRegister not_register1(leftside);\n";
+    NotRegister not_register1(leftside);
+    cout << "Creating not_register2 with the assignment operator (=).\n";
+    cout << "NotRegister not_register2 = not_register1;\n";
+    NotRegister not_register2 = not_register1;
+    cout << "not_register2 = ";
+    cout << "0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << not_register2.getBitString(my_chip)->getFieldRight(
+                0, BITSTRING_BIT_WIDTH)
+         << "\n";
+
+    // LeftShiftRegister
+    cout << "\nCreating leftshift_register1 with leftside register.\n";
+    cout << "LeftShiftRegister leftshift_register1(leftside,4);\n";
+    LeftShiftRegister leftshift_register1(leftside, 4);
+    cout << "Creating leftshift_register2 with the assignment operator (=).\n";
+    cout << "LeftShiftRegister leftshift_register2 = leftshift_register1;\n";
+    LeftShiftRegister leftshift_register2 = leftshift_register1;
+    cout << "leftshift_register2 = ";
+    cout << "0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << leftshift_register2.getBitString(my_chip)->getFieldRight(
+                0, BITSTRING_BIT_WIDTH)
+         << "\n";
+
+    // RightShiftRegister
+    cout << "\nCreating rightshift_register1 with leftside register.\n";
+    cout << "RightShiftRegister rightshift_register1(leftside,4);\n";
+    RightShiftRegister rightshift_register1(leftside, 4);
+    cout << "Creating rightshift_register2 with the assignment operator (=).\n";
+    cout << "RightShiftRegister rightshift_register2 = rightshift_register1;\n";
+    RightShiftRegister rightshift_register2 = rightshift_register1;
+    cout << "rightshift_register2 = ";
+    cout << "0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << rightshift_register2.getBitString(my_chip)->getFieldRight(
+                0, BITSTRING_BIT_WIDTH)
+         << "\n";
+
+    // OrRegister
+    cout << "\nCreating or_register1 with leftside & rightside registers.\n";
+    cout << "OrRegister or_register1(leftside,rightside);\n";
+    OrRegister or_register1(leftside, rightside);
+    cout << "or_register1 = ";
+    cout << "0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << or_register1.getBitString(my_chip)->getFieldRight(
+                0, BITSTRING_BIT_WIDTH)
+         << "\n";
+    cout << "Creating or_register2 with the assignment operator (=).\n";
+    cout << "OrRegister or_register2 = or_register1;\n";
+    OrRegister or_register2 = or_register1;
+    cout << "or_register2 = ";
+    cout << "0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << or_register2.getBitString(my_chip)->getFieldRight(
+                0, BITSTRING_BIT_WIDTH)
+         << "\n";
+
+    //***** == operator *****
+    cout << "\nOperator \"==\" (equality)\n\n";
+    cout << "Operation  Register1 = Register2    Equality\n";
+
+    // Constant Register
+    ConstantRegister cr1(leftside);
+    ConstantRegister cr2(rightside);
+    cout << " Constant    0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4)
+         << hex
+         << cr1.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    cout << "     0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << cr2.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    if (cr1 == cr2)
+        cout << "      Equal\n";
+    else
+        cout << "      Not Equal\n";
+
+    // And Register
+    AndRegister and1(leftside, rightside);
+    AndRegister and2(leftside, rightside);
+
+    cout << " And         0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4)
+         << hex
+         << and1.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    cout << "     0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << and2.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    if (and1 == and2)
+        cout << "      Equal\n";
+    else
+        cout << "      Not Equal\n";
+
+    // Not Register
+    NotRegister nr1(leftside);
+    NotRegister nr2(rightside);
+    cout << " Not         0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4)
+         << hex
+         << nr1.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    cout << "     0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << nr2.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    if (nr1 == nr2)
+        cout << "      Equal\n";
+    else
+        cout << "      Not Equal\n";
+
+    // Left Shift Register
+    LeftShiftRegister lsr1(leftside, 4);
+    LeftShiftRegister lsr2(rightside, 4);
+    cout << " Left Shift  0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4)
+         << hex
+         << lsr1.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    cout << "     0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << lsr2.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    if (lsr1 == lsr2)
+        cout << "      Equal\n";
+    else
+        cout << "      Not Equal\n";
+
+    // Right Shift Register
+    RightShiftRegister rsr1(leftside, 6);
+    RightShiftRegister rsr2(rightside, 6);
+    cout << " Right Shift 0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4)
+         << hex
+         << rsr1.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    cout << "     0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << rsr2.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    if (rsr1 == rsr2)
+        cout << "      Equal\n";
+    else
+        cout << "      Not Equal\n";
+
+    // Or Register
+    OrRegister or1(leftside, rightside);
+    OrRegister or2(leftside, rightside);
+    cout << " OR          0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4)
+         << hex
+         << or1.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    cout << "     0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << or2.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    if (or1 == or2)
+        cout << "      Equal\n";
+    else
+        cout << "      Not Equal\n";
+
+    //***** < operator *****
+    cout << "\nOperator \"<\" (equality)\n\n";
+    cout << "Operation  Register1 < Register2  Equal/Less Than\n";
+
+    // Constant Register
+    ConstantRegister cr1a(leftside);
+    ConstantRegister cr2a(rightside);
+    cout << " Constant    0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4)
+         << hex
+         << cr1a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    cout << "     0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << cr2a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    // if (cr1a < cr2a)
+    if (cr1a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH) <
+        cr2a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH))
+        cout << "      Less Than\n";
+    else
+        cout << "      Not Less Than\n";
+
+    // And Register
+    AndRegister and1a(leftside, rightside);
+    AndRegister and2a(leftside, rightside);
+    cout << " And         0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4)
+         << hex
+         << and1a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    cout << "     0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << and2a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    // if (and2a < and1a)
+    if (and1a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH) <
+        and2a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH))
+        cout << "      Less Than\n";
+    else
+        cout << "      Not Less Than\n";
+
+    // Not Register
+    NotRegister nr1a(leftside);
+    NotRegister nr2a(rightside);
+    cout << " Not         0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4)
+         << hex
+         << nr1a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    cout << "     0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << nr2a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    // if (nr1a < nr2a) Paul
+    if (nr1a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH) <
+        nr2a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH))
+        cout << "      Less Than\n";
+    else
+        cout << "      Not Less Than\n";
+
+    // Left Shift Register
+    LeftShiftRegister lsr1a(leftside, 4);
+    LeftShiftRegister lsr2a(leftside, 4);
+    cout << " Left Shift  0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4)
+         << hex
+         << lsr1a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    cout << "     0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << lsr2a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    // if (lsr1a < lsr2a)
+    if (lsr1a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH) <
+        lsr2a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH))
+        cout << "      Less Than\n";
+    else
+        cout << "      Not Less Than\n";
+
+    // Right Shift Register
+    RightShiftRegister rsr1a(leftside, 4);
+    RightShiftRegister rsr2a(leftside, 4);
+    cout << " Right Shift 0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4)
+         << hex
+         << rsr1a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    cout << "     0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << rsr2a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    // if (rsr1a < rsr2a)
+    if (rsr1a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH) <
+        rsr2a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH))
+        cout << "      Less Than\n";
+    else
+        cout << "      Not Less Than\n";
+
+    // Or Register
+    OrRegister or1a(leftside, rightside);
+    OrRegister or2a(leftside, rightside);
+    cout << " Or          0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4)
+         << hex
+         << or1a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    cout << "     0x" << setfill('0') << setw(BITSTRING_BIT_WIDTH / 4) << hex
+         << or2a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH);
+    // if (or1a < or2a)
+    if (or1a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH) <
+        or2a.getBitString(my_chip)->getFieldRight(0, BITSTRING_BIT_WIDTH))
+        cout << "      Less Than\n";
+    else
+        cout << "      Not Less Than\n";
+
+    return (0);
+}
diff --git a/test/meson.build b/test/meson.build
index cdf8812..ce1e5da 100644
--- a/test/meson.build
+++ b/test/meson.build
@@ -7,7 +7,7 @@
 # build g-test framework unit tests
 gtests = [
     'bit_string_test',
-    'flyweight_test',
+    'flyweight_test'
 ]
 
 gtest = dependency('gtest', main : true, required : false, method : 'system')
@@ -19,3 +19,11 @@
                             include_directories : incdir))
   endforeach
 endif
+
+# build unit-test framework
+tests = ['hei_operator_register_testcase']
+
+foreach t : tests
+        test(t, executable(t.underscorify(), t + '.cpp', test_src, \
+                            include_directories : incdir))
+endforeach