Extended Boolean class

- added logical operators
- extended tests for Boolean class

source/boxing/Boolean.cpp

@@ -23,6 +23,36 @@ ls_std::Boolean::operator bool() const
   return this->value;
 }
 
+bool ls_std::Boolean::operator&&(const Boolean &_boolean) const
+{
+  return this->value && _boolean;
+}
+
+bool ls_std::Boolean::operator&&(bool _value) const
+{
+  return this->value && _value;
+}
+
+bool ls_std::Boolean::operator&&(int _value) const
+{
+  return this->value && _value;
+}
+
+bool ls_std::Boolean::operator||(const Boolean &_boolean) const
+{
+  return this->value || _boolean;
+}
+
+bool ls_std::Boolean::operator||(bool _value) const
+{
+  return this->value || _value;
+}
+
+bool ls_std::Boolean::operator||(int _value) const
+{
+  return this->value || _value;
+}
+
 void ls_std::Boolean::parse(std::string parseText)
 {
   std::transform(parseText.begin(), parseText.end(), parseText.begin(), ::tolower);

source/boxing/Boolean.hpp

@@ -38,18 +38,25 @@ namespace ls_std {
         return !_boolean.value;
       }
 
-//      bool operator&&(const Boolean& _boolean) const;
-//      bool operator&&(bool _value) const;
-//      bool operator&&(int _value) const;
-//      bool operator||(const Boolean& _boolean) const;
-//      bool operator||(bool _value) const;
-//      bool operator||(int _value) const;
+      bool operator&&(const Boolean& _boolean) const;
+      bool operator&&(bool _value) const;
+      bool operator&&(int _value) const;
+      bool operator||(const Boolean& _boolean) const;
+      bool operator||(bool _value) const;
+      bool operator||(int _value) const;
 
       // implementation
 
       void parse(std::string parseText) override;
       std::string toString() override;
 
+      // additional functionality
+
+//      static bool XOR(const Boolean& _leftExpression, const Boolean& _rightExpression);
+//      static bool AND(const Boolean& _leftExpression, const Boolean& _rightExpression);
+//      static bool NOT(const Boolean& _leftExpression, const Boolean& _rightExpression);
+//      static bool OR(const Boolean& _leftExpression, const Boolean& _rightExpression);
+
     private:
 
       bool value {};

test/cases/boxing/BooleanTest.cpp

@@ -33,6 +33,60 @@ namespace {
     ASSERT_STREQ("true", _stream.str().c_str());
   }
 
+  TEST_F(BooleanTest, operatorNot) {
+    ls_std::Boolean expression {};
+    ASSERT_TRUE(!expression);
+  }
+
+  TEST_F(BooleanTest, operatorNotNegative) {
+    ls_std::Boolean expression {true};
+    ASSERT_FALSE(!expression);
+  }
+
+  TEST_F(BooleanTest, operatorAnd) {
+    ls_std::Boolean expressionA {true};
+    ls_std::Boolean expressionB {3 == 3};
+
+    ASSERT_TRUE(expressionA && expressionB);
+    ASSERT_TRUE(expressionB && expressionA);
+    ASSERT_TRUE(expressionA && true);
+    ASSERT_TRUE(expressionA && 1);
+    ASSERT_TRUE(1 && expressionB);
+  }
+
+  TEST_F(BooleanTest, operatorAndNegative) {
+    ls_std::Boolean expressionA {true};
+    ls_std::Boolean expressionB {3 == 4};
+
+    ASSERT_FALSE(expressionA && expressionB);
+    ASSERT_FALSE(expressionB && expressionA);
+    ASSERT_FALSE(expressionB && (3 == 4));
+    ASSERT_FALSE(expressionB && 0);
+    ASSERT_FALSE(expressionB && false);
+  }
+
+  TEST_F(BooleanTest, operatorOr) {
+    ls_std::Boolean expressionA {false};
+    ls_std::Boolean expressionB {3 == 3};
+
+    ASSERT_TRUE(expressionA || expressionB);
+    ASSERT_TRUE(expressionB || expressionA);
+    ASSERT_TRUE(expressionA || 1);
+    ASSERT_TRUE(expressionA || true);
+    ASSERT_TRUE(1 || expressionA);
+  }
+
+  TEST_F(BooleanTest, operatorOrNegative) {
+    ls_std::Boolean expressionA {false};
+    ls_std::Boolean expressionB {3 == 4};
+
+    ASSERT_FALSE(expressionA || expressionB);
+    ASSERT_FALSE(expressionB || expressionA);
+    ASSERT_FALSE(expressionA || 0);
+    ASSERT_FALSE(expressionA || false);
+    ASSERT_FALSE(0 || expressionA);
+  }
+
   TEST_F(BooleanTest, parse)
   {
     ls_std::Boolean expression {};