init calculator unit test

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.5.1)
 project(dummy_cmake_project)
 
-set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD 17)
 list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
 
 set(SOURCES project.cc)

src/Calculator/calculator.cpp

@@ -0,0 +1,140 @@
+#include "include/calculator.h"
+#include <iostream>
+#include <algorithm>
+#include <sstream>
+#include <iterator>
+
+Calculator::Calculator()
+{
+}
+
+double Calculator::calculate(std::string input)
+{
+    clear();
+
+    for (auto token : tokenize(input)) {
+
+        if (isOperand(token)) {
+            handleOperandToken(token);
+            continue;
+        }
+
+        if (isOperator(token)) {
+            if (!handleOperatorToken(token)) {
+                return {};
+            }
+            continue;
+        }
+
+        m_error = "input simbol: " + token + " not supported!";
+        return 0.0;
+    }
+
+    return m_tmp_operands.top();
+}
+
+std::string Calculator::error() const
+{
+    return m_error;
+}
+
+void Calculator::clear()
+{
+    m_tmp_operands = {};
+    m_error.clear();
+}
+
+Calculator::operands Calculator::popOperands()
+{
+    if (m_tmp_operands.size() < min_operandsNumber) {
+        m_error = "wrong input string!";
+        return {};
+    }
+
+    auto op2 = m_tmp_operands.top();
+    m_tmp_operands.pop();
+    auto op1 = m_tmp_operands.top();
+    m_tmp_operands.pop();
+
+    return std::make_pair(op1, op2);
+}
+
+Calculator::result Calculator::calculateNext(operands operands, char oper)
+{
+    auto op1 = operands.first;
+    auto op2 = operands.second;
+
+    switch (oper) {
+
+    case '*' :
+        return op1 * op2;
+
+    case '/' :
+        if (op2 == 0) {
+            m_error = "division by zero is undefined";
+            return {};
+        }
+        return op1 / op2;
+
+    case '+' :
+        return op1 + op2;
+
+    case '-' :
+        return op1 - op2;
+
+    default:
+        return {};
+    }
+}
+
+void Calculator::handleOperandToken(const std::string &token)
+{
+    m_tmp_operands.push(atof(token.c_str()));
+}
+
+Calculator::result Calculator::handleOperatorToken(const std::string &token)
+{
+    auto res = calculateNext(popOperands(), token.at(0));
+
+    if (!res) {
+        return {};
+    }
+
+    m_tmp_operands.push(res.value());
+    return res;
+}
+
+Calculator::tokens Calculator::tokenize(const std::string &input) const
+{
+    std::istringstream inputStream(input);
+    std::vector<std::string> tokens(std::istream_iterator<std::string>{inputStream},
+                                    std::istream_iterator<std::string>());
+
+    if (tokens.empty()) {
+        return {};
+    }
+
+    return tokens;
+}
+
+
+bool Calculator::isOperator(const std::string &oper) const {
+    auto _oper = oper.at(0);
+    return std::find(m_availableOperators.begin(), m_availableOperators.end(), _oper) != m_availableOperators.end();
+}
+
+bool Calculator::isOperand(std::string token) const
+{
+    // consider negative numbers
+    if (token.at(0) == '-') {
+        token.erase(0, 1);
+    }
+    bool isDigit = !token.empty() &&
+                    std::find_if(token.begin(),
+                                 token.end(),
+                                 [](unsigned char c) {
+                                    return !std::isdigit(c);
+                                    }
+                                 ) == token.end();
+    return isDigit;
+}

src/Calculator/include/calculator.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <string>
+#include <array>
+#include <stack>
+#include <optional>
+#include <utility>
+#include <vector>
+
+/**
+ * @brief Polish notation calculator
+ */
+
+class Calculator{
+
+public:
+    Calculator();
+
+    double calculate(std::string input);
+    void clear();
+    std::string error() const;
+
+private:
+    using result = std::optional<double>;
+    using operands = std::pair<double, double>;
+    using tokens = std::vector<std::string>;
+
+private:
+    operands popOperands();
+    result calculateNext(operands operands, char oper);
+    void handleOperandToken(const std::string& token);
+    result handleOperatorToken(const std::string& token);
+
+    tokens tokenize(const std::string& input) const;
+    bool isOperator(const std::string& oper) const;
+    bool isOperand(std::string token) const;
+
+    std::stack<double> m_tmp_operands;
+    std::string m_error;
+
+    static constexpr std::array<char, 4> m_availableOperators{'*', '/', '+', '-'};
+    static constexpr int min_operandsNumber{2};
+};

test/CMakeLists.txt

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

test/calculator_test.cpp

@@ -0,0 +1,65 @@
+#include <gtest/gtest.h>
+
+#include "../src/Calculator/include/calculator.h"
+
+#include <iostream>
+
+class CalculatorTest : public ::testing::Test {
+
+public:
+    Calculator calculator;
+};
+
+TEST_F(CalculatorTest, AddPositive) {
+    ASSERT_EQ(calculator.calculate("2 3 +"), 5);
+}
+
+TEST_F(CalculatorTest, AddNegative) {
+    ASSERT_EQ(calculator.calculate("-2 -3 +"), -5);
+}
+
+TEST_F(CalculatorTest, Substract) {
+    ASSERT_EQ(calculator.calculate("5 2 -"), 3);
+}
+
+TEST_F(CalculatorTest, Multiply) {
+    ASSERT_EQ(calculator.calculate("3 7 *"), 21);
+}
+
+TEST_F(CalculatorTest, Devide) {
+    ASSERT_EQ(calculator.calculate("21 7 /"), 3);
+}
+
+TEST_F(CalculatorTest, MultiplyByZero) {
+    ASSERT_EQ(calculator.calculate("21 0 *"), 0);
+}
+
+TEST_F(CalculatorTest, DevideByZero) {
+    ASSERT_EQ(calculator.calculate("21 0 /"), 0);
+    ASSERT_EQ(calculator.error(), "division by zero is undefined");
+}
+
+TEST_F(CalculatorTest, ComplexAdd) {
+    ASSERT_EQ(calculator.calculate("2 3 6 + +"), 11);
+}
+
+TEST_F(CalculatorTest, ComplexPriorityOperation) {
+    ASSERT_EQ(calculator.calculate("2 3 6 + *"), 18);
+}
+
+TEST_F(CalculatorTest, ComplexPriorityOperationMultiplyByZero) {
+    ASSERT_EQ(calculator.calculate("2 3 0 + *"), 6);
+}
+
+TEST_F(CalculatorTest, ComplexPriorityOperationIndefinite) {
+    ASSERT_EQ(calculator.calculate("0 3 2 + /"), 0);
+}
+
+TEST_F(CalculatorTest, SimbolNotSuported) {
+    ASSERT_EQ(calculator.calculate("2 3 #"), 0);
+    ASSERT_EQ(calculator.error(), "input simbol: # not supported!");
+}
+
+TEST_F(CalculatorTest, VeryComplex) {
+    ASSERT_EQ(calculator.calculate("4 12 3 + * 2 / 5 5 + * 100 2 * - 2 /"), 50);
+}