perf(infinite number): implement operations function

They don’t implement infinite value, it will be implemented in the end
TheRealPad · Feb 29, 2024 · 69e290c · 69e290c
1 parent 3faf749
commit 69e290c
Show file tree

Hide file tree

Showing 4 changed files with 156 additions and 24 deletions.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -6,11 +6,11 @@ project(Calculator VERSION 1.0
         DESCRIPTION "I love C++"
         LANGUAGES CXX)
 
+set(CMAKE_CXX_STANDARD 17)
+
 SET(NAME "johnDoe")
 SET(TEST_NAME "unit_test")
 
-set(CMAKE_CXX_STANDARD 17)
-
 set(SRC
         src/Calculator/Calculator.cpp
         src/Error/Error.cpp
@@ -24,6 +24,7 @@ set(TEST_SRC
         tests/Error.cpp
         tests/Calculator.cpp
         tests/OperationsPriorities.cpp
+        tests/InfiniteNumber.cpp
 )
 
 add_executable(${NAME} main.cpp ${SRC})

diff --git a/src/InfiniteNumbers/InfiniteNumber.cpp b/src/InfiniteNumbers/InfiniteNumber.cpp
@@ -2,34 +2,41 @@
 // Created by Pierre-Alexandre Delgado on 28/02/2024.
 //
 
-#include "InfiniteNumber.h"
-
-#include <iostream>
 #include <map>
+#include "InfiniteNumber.h"
+#include "Error.h"
 
 namespace Operations {
 
-    std::string InfiniteNumber::addition(std::string &a, std::string &b) {
-        return "";
+    std::string InfiniteNumber::addition(std::string const &a, std::string const &b) {
+        const int result = std::stoi( a ) + std::stoi( b );
+        return std::to_string(result);
     }
 
-    std::string InfiniteNumber::substraction(std::string &a, std::string &b) {
-        return "";
+    std::string InfiniteNumber::substraction(std::string const &a, std::string const &b) {
+        const int result = std::stoi( a ) - std::stoi( b );
+        return std::to_string(result);
     }
 
-    std::string InfiniteNumber::division(std::string &a, std::string &b) {
-        return "";
+    std::string InfiniteNumber::division(std::string const &a, std::string const &b) {
+        if (b == "0")
+            throw ErrorCalculator::Error(ErrorCalculator::Error::DIVISION_BY_0);
+        const int result = std::stoi( a ) / std::stoi( b );
+        return std::to_string(result);
     }
 
-    std::string InfiniteNumber::modulo(std::string &a, std::string &b) {
-        return "";
+    std::string InfiniteNumber::modulo(std::string const &a, std::string const &b) {
+        if (b == "0")
+            throw ErrorCalculator::Error(ErrorCalculator::Error::DIVISION_BY_0);
+        const int result = std::stoi( a ) % std::stoi( b );
+        return std::to_string(result);
     }
 
-    std::string InfiniteNumber::multiplication(std::string &a, std::string &b) {
-        return "";
+    std::string InfiniteNumber::multiplication(std::string const &a, std::string const &b) {
+        const int result = std::stoi( a ) * std::stoi( b );
+        return std::to_string(result);
     }
 
-
     std::string InfiniteNumber::makeOperation(std::string &operation) {
         std::string a;
         std::string b;
@@ -43,7 +50,12 @@ namespace Operations {
                 break;
             }
         }
-        return this->addition(a, b);
+        auto it = this->_operationMap.find(sign);
+        if (it != this->_operationMap.end()) {
+            OperationFunction func = it->second;
+            return (func)(a, b);
+        }
+        throw ErrorCalculator::Error("Unknown operator");
     }
 
 }
diff --git a/src/InfiniteNumbers/InfiniteNumber.h b/src/InfiniteNumbers/InfiniteNumber.h
@@ -5,20 +5,32 @@
 #ifndef INFINITENUMBER_H
 #define INFINITENUMBER_H
 
-#include <IOperations.hpp>
+#include <map>
+#include "IOperations.hpp"
 
 namespace Operations {
 
     class InfiniteNumber : public IOperations {
         public:
-            std::string makeOperation(std::string &operation);
+            InfiniteNumber() = default;
+            ~InfiniteNumber() override = default;
+            std::string makeOperation(std::string &operation) override;
 
         private:
-            std::string addition(std::string &a, std::string &b);
-            std::string substraction(std::string &a, std::string &b);
-            std::string multiplication(std::string &a, std::string &b);
-            std::string division(std::string &a, std::string &b);
-            std::string modulo(std::string &a, std::string &b);
+            static std::string addition(std::string const &a, std::string const &b);
+            static std::string substraction(std::string const &a, std::string const &b);
+            static std::string multiplication(std::string const &a, std::string const &b);
+            static std::string division(std::string const &a, std::string const &b);
+            static std::string modulo(std::string const &a, std::string const &b);
+
+            using OperationFunction = std::string (*)(const std::string&, const std::string&);
+            const std::map<std::string, OperationFunction> _operationMap = {
+                {"+", &InfiniteNumber::addition},
+                {"-", &InfiniteNumber::substraction},
+                {"*", &InfiniteNumber::multiplication},
+                {"/", &InfiniteNumber::division},
+                {"%", &InfiniteNumber::modulo}
+            };
     };
 
 } // Operation

diff --git a/tests/InfiniteNumber.cpp b/tests/InfiniteNumber.cpp
@@ -0,0 +1,107 @@
+#include <gtest/gtest.h>
+#include "InfiniteNumber.h"
+
+TEST(InfiniteNumber, AdditionOne)
+{
+    std::unique_ptr<Operations::IOperations> infiniteNumber = std::make_unique<Operations::InfiniteNumber>();
+    std::string str = "9+3";
+    EXPECT_EQ(infiniteNumber->makeOperation(str), "12");
+}
+
+TEST(InfiniteNumber, AdditionTwo)
+{
+    std::unique_ptr<Operations::IOperations> infiniteNumber = std::make_unique<Operations::InfiniteNumber>();
+    std::string str = "-7+3";
+    EXPECT_EQ(infiniteNumber->makeOperation(str), "-4");
+}
+
+TEST(InfiniteNumber, AdditionThree)
+{
+    std::unique_ptr<Operations::IOperations> infiniteNumber = std::make_unique<Operations::InfiniteNumber>();
+    std::string str = "-7+-3";
+    EXPECT_EQ(infiniteNumber->makeOperation(str), "-10");
+}
+
+TEST(InfiniteNumber, SubstractionOne)
+{
+    std::unique_ptr<Operations::IOperations> infiniteNumber = std::make_unique<Operations::InfiniteNumber>();
+    std::string str = "9-3";
+    EXPECT_EQ(infiniteNumber->makeOperation(str), "6");
+}
+
+TEST(InfiniteNumber, SubstractionTwo)
+{
+    std::unique_ptr<Operations::IOperations> infiniteNumber = std::make_unique<Operations::InfiniteNumber>();
+    std::string str = "-7-3";
+    EXPECT_EQ(infiniteNumber->makeOperation(str), "-10");
+}
+
+TEST(InfiniteNumber, SubstractionThree)
+{
+    std::unique_ptr<Operations::IOperations> infiniteNumber = std::make_unique<Operations::InfiniteNumber>();
+    std::string str = "-7--3";
+    EXPECT_EQ(infiniteNumber->makeOperation(str), "-4");
+}
+
+TEST(InfiniteNumber, MultiplicationOne)
+{
+    std::unique_ptr<Operations::IOperations> infiniteNumber = std::make_unique<Operations::InfiniteNumber>();
+    std::string str = "9*3";
+    EXPECT_EQ(infiniteNumber->makeOperation(str), "27");
+}
+
+TEST(InfiniteNumber, MultiplicationTwo)
+{
+    std::unique_ptr<Operations::IOperations> infiniteNumber = std::make_unique<Operations::InfiniteNumber>();
+    std::string str = "-7*3";
+    EXPECT_EQ(infiniteNumber->makeOperation(str), "-21");
+}
+
+TEST(InfiniteNumber, MultiplicationThree)
+{
+    std::unique_ptr<Operations::IOperations> infiniteNumber = std::make_unique<Operations::InfiniteNumber>();
+    std::string str = "-7*-3";
+    EXPECT_EQ(infiniteNumber->makeOperation(str), "21");
+}
+
+TEST(InfiniteNumber, DivisionOne)
+{
+    std::unique_ptr<Operations::IOperations> infiniteNumber = std::make_unique<Operations::InfiniteNumber>();
+    std::string str = "9/3";
+    EXPECT_EQ(infiniteNumber->makeOperation(str), "3");
+}
+
+TEST(InfiniteNumber, DivisionTwo)
+{
+    std::unique_ptr<Operations::IOperations> infiniteNumber = std::make_unique<Operations::InfiniteNumber>();
+    std::string str = "-7/3";
+    EXPECT_EQ(infiniteNumber->makeOperation(str), "-2");
+}
+
+TEST(InfiniteNumber, DivisionThree)
+{
+    std::unique_ptr<Operations::IOperations> infiniteNumber = std::make_unique<Operations::InfiniteNumber>();
+    std::string str = "-7/-3";
+    EXPECT_EQ(infiniteNumber->makeOperation(str), "2");
+}
+
+TEST(InfiniteNumber, RestOne)
+{
+    std::unique_ptr<Operations::IOperations> infiniteNumber = std::make_unique<Operations::InfiniteNumber>();
+    std::string str = "9%3";
+    EXPECT_EQ(infiniteNumber->makeOperation(str), "0");
+}
+
+TEST(InfiniteNumber, RestTwo)
+{
+    std::unique_ptr<Operations::IOperations> infiniteNumber = std::make_unique<Operations::InfiniteNumber>();
+    std::string str = "-7%3";
+    EXPECT_EQ(infiniteNumber->makeOperation(str), "-1");
+}
+
+TEST(InfiniteNumber, RestThree)
+{
+    std::unique_ptr<Operations::IOperations> infiniteNumber = std::make_unique<Operations::InfiniteNumber>();
+    std::string str = "-7%-3";
+    EXPECT_EQ(infiniteNumber->makeOperation(str), "-1");
+}