calculator: add calculator and unittest for tdd

.gitignore

@@ -1,3 +1,4 @@
 build
 CMakeLists.txt.user*
 
+.vscode

CMakeLists.txt

@@ -4,7 +4,7 @@ project(dummy_cmake_project)
 set(CMAKE_CXX_STANDARD 14)
 list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
 
-set(SOURCES project.cc)
+set(SOURCES project.cc calculator.cc)
 add_library(ProjectLib ${SOURCES})
 
 add_executable(project main.cc run.cc)

calculator.cc

@@ -0,0 +1,76 @@
+#include "calculator.h"
+
+namespace dev {
+
+bool Calculator::isOperator(char op){
+    switch (op){
+        case '+':
+        case '-':
+        case '*':
+        case '/':
+            return true;
+        default:
+            return false;
+    }
+}
+
+void Calculator::getVariables(float& firstOperand, float& secondOperand)
+{
+    firstOperand = mOperandStack.top();
+    mOperandStack.pop();
+    secondOperand = mOperandStack.top();
+    mOperandStack.pop();
+}
+
+double Calculator::evaluate(const std::string& expression)
+{
+    double ret =0.0;
+    float firstOperand,secondOperand;
+    firstOperand=secondOperand=0.0;
+    for(int index=0;index < expression.length();index++)
+    {
+        // ignore the spaces
+        if (isspace(expression[index])){
+            continue;
+        }
+
+        // Push to stack, if digit
+        if(isdigit(expression[index]))
+        {
+            std::string digitsStr;
+
+            while (index < expression.size() && ((isdigit(expression[index]) || expression[index] == '.')))
+            {
+                digitsStr.push_back(expression[index]);
+                index++;
+            }
+
+            mOperandStack.push(stof(digitsStr));
+            // Decrease index as currently points to advanced element
+            index--;
+        }
+        // Check if operator and perform the operation of numbers from stack
+        else if (isOperator(expression[index])){
+            getVariables(firstOperand,secondOperand);
+            if (expression[index] == '+'){
+                ret = firstOperand+secondOperand;
+            }
+            if (expression[index] == '-'){
+                ret = secondOperand-firstOperand;
+            }
+            if (expression[index] == '*'){
+                ret = firstOperand*secondOperand;
+            }
+            if (expression[index] == '/'){
+                ret = secondOperand/firstOperand;
+            }
+
+            // push the final result
+            mOperandStack.push(ret);
+        }
+        }
+    // return answer
+    return mOperandStack.top();
+}
+
+}  // namespace dev

calculator.h

@@ -0,0 +1,24 @@
+#include<string>
+#include<stack>
+namespace dev {
+
+class Calculator {
+public:
+    Calculator() = default;
+    ~Calculator() = default;
+
+    /**
+     * method to evaluate the expression
+     * param expression string fetched from console input
+     */
+    double evaluate(const std::string& expression);
+
+private:
+
+    //Stack to hold the numbers
+    std::stack<float> mOperandStack;
+    bool isOperator(char op);
+    void getVariables(float& var1, float& var2);
+};
+
+}  // namespace calculator

main.cc

@@ -1,7 +1,16 @@
 #include "run.h"
 #include "project.h"
+#include "calculator.h"
+#include<iostream>
 
 int main() {
+
+  dev::Calculator calc;
+  std::string s;
+  std::cout<<"Enter the string: ";
+  std::getline(std::cin,s);
+  std::cout<<"Result:"<<calc.evaluate(s)<<std::endl;
+
   dev::Project p;
   return run(p);
 }

project.cc

@@ -1,5 +1,4 @@
 #include "project.h"
-
 namespace dev {
 
 int Project::run() {

test/CMakeLists.txt

@@ -8,3 +8,6 @@ target_link_libraries(ProjectTest PUBLIC ProjectLib)
 
 add_executable (RunTest ${CMAKE_SOURCE_DIR}/run.cc run_tests.cc)
 add_gtest(RunTest)
+
+add_executable (CalculatorTest ${CMAKE_SOURCE_DIR}/calculator.cc calculator_test.cc)
+add_gtest(CalculatorTest)

test/calculator_test.cc

@@ -0,0 +1,60 @@
+#include "calculator.h"
+
+#include <gtest/gtest.h>
+
+namespace dev {
+namespace testing {
+
+class CalculatorTest : public ::testing::Test {
+ public:
+  void SetUp() override {}
+  void TearDown() override {}
+  Calculator calc_;
+};
+
+TEST_F(CalculatorTest, Add) {
+  ASSERT_DOUBLE_EQ(7.0, calc_.evaluate("5 2 +"));
+}
+
+TEST_F(CalculatorTest, Subtract) {
+  ASSERT_DOUBLE_EQ(3.0, calc_.evaluate("5 2 -"));
+}
+
+TEST_F(CalculatorTest, SubtractNegative) {
+  ASSERT_DOUBLE_EQ(-3.0, calc_.evaluate("2 5 -"));
+}
+
+TEST_F(CalculatorTest, Multiply) {
+  ASSERT_DOUBLE_EQ(10.0, calc_.evaluate("5 2 *"));
+}
+
+TEST_F(CalculatorTest, CalcDiv) {
+  ASSERT_DOUBLE_EQ(2.5, calc_.evaluate("5 2 /"));
+}
+
+TEST_F(CalculatorTest, AddFloat) {
+  ASSERT_DOUBLE_EQ(5.0, calc_.evaluate("2.5 2.5 +"));
+}
+
+TEST_F(CalculatorTest, SubFloat) {
+  ASSERT_DOUBLE_EQ(-1.0, calc_.evaluate("1.5 2.5 -"));
+}
+
+TEST_F(CalculatorTest, MultFloat) {
+  ASSERT_DOUBLE_EQ(6.25, calc_.evaluate("2.5 2.5 *"));
+}
+
+TEST_F(CalculatorTest, Divfloat) {
+  ASSERT_DOUBLE_EQ(6.0, calc_.evaluate("15.0 2.5 /"));
+}
+
+TEST_F(CalculatorTest, MultipleOperator1) {
+  ASSERT_DOUBLE_EQ(2.25, calc_.evaluate("1.5 3 + 2.0 /"));
+}
+
+TEST_F(CalculatorTest, MultipleOperator2) {
+  ASSERT_DOUBLE_EQ(0, calc_.evaluate("2.5 2.5 - 4.0 *"));
+}
+
+}  // namespace testing
+}  // namespace dev