Feedback

TDDKata/Calculator.cpp

@@ -3,10 +3,50 @@
 
 int Calculator::Add(std::string expression)
 {
+
     return 0;
 }
 
-int Calculator::Add(char* expression)
+int Calculator::Add(const char* expression)
 {
-    throw 0;
+    const char* delim = ",\n";
+    char* dup = strdup(expression);
+    int sum = 0;
+    size_t len = strlen(expression);
+    if (!len)
+        return 0;
+    if (strstr(dup, ",\n") != NULL)
+        return -1;
+    char* new_delim = strstr(dup, "//");
+    if ((new_delim) && (new_delim == dup)) {
+        if (strstr(dup, "\n") == NULL) {
+            return -1;
+        } else {
+            char * dup2 = strdup(dup);
+            strcpy(dup2, new_delim + 2);
+            char *ch = dup2;
+            while (*ch != '\n')
+                ch++;
+            *ch = 0;
+            delim = dup2;
+
+            dup = strstr(dup, "\n") + 1 ;
+
+        }
+    }
+
+    char* operand  = strtok(dup, delim);
+    while (operand != NULL){
+        char* ch = operand;
+        while (*ch) {
+            if (!isdigit(*ch))
+                return -1;
+            ch++;
+        }
+
+        sum += atoi(operand);
+        operand = strtok(NULL, delim);
+    } 
+
+    return sum;
 }

TDDKata/Calculator.h

@@ -5,6 +5,9 @@
 /// </summary>
 class Calculator
 {
+
+public:
+
 	/// <summary>
 	/// Sum of elements expression
 	/// </summary>
@@ -16,6 +19,6 @@ class Calculator
 	/// </summary>
 	/// <param name="expression">Input expression</param>
 	/// <returns>Value of sum expression of expression</returns>
-	int Add(char* expression);
+	int Add(const char* expression);
 };
 

TDDKata/TDDKata.vcxproj

@@ -35,16 +35,20 @@
   <ItemGroup>
     <ClInclude Include="Calculator.h" />
     <ClInclude Include="pch.h" />
+    <ClInclude Include="TestFixtureWithParam.h" />
+    <ClInclude Include="TestFixture.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Calculator.cpp" />
+    <ClCompile Include="TestFixtureWithParam.cpp" />
     <ClCompile Include="test.cpp" />
     <ClCompile Include="pch.cpp">
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
     </ClCompile>
+    <ClCompile Include="TestFixture.cpp" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />

TDDKata/TestFixture.cpp

@@ -0,0 +1,12 @@
+#include "pch.h"
+#include "TestFixture.h"
+
+void TestFixture::SetUp()
+{
+	calc = new Calculator();
+}
+
+void TestFixture::TearDown()
+{
+	delete calc;
+}

TDDKata/TestFixture.h

@@ -0,0 +1,12 @@
+#pragma once
+#include "pch.h"
+#include "Calculator.h"
+class TestFixture: public ::testing::Test
+{
+protected:
+	Calculator * calc;
+	void SetUp() override;
+
+	void TearDown() override;
+};
+

TDDKata/TestFixtureWithParam.cpp

@@ -0,0 +1,24 @@
+#include "pch.h"
+#include "TestFixtureWithParam.h"
+
+INSTANTIATE_TEST_CASE_P(PositiveSet, TestFixtureWithParam,
+	::testing::Values(
+		Param("0,1,2" , 3), 
+		Param("0,0,0", 0),
+		Param("1", 1),
+		Param("1,2", 3),
+		Param("", 0),
+		Param("1,2,3,4,5,6", 21),
+		Param("1\n,2,3", 6),
+		Param("//;\n1;2", 3)
+		));
+
+INSTANTIATE_TEST_CASE_P(NegativeSet, TestFixtureWithParam,
+	::testing::Values(
+		Param("abc", -1),
+		Param("a,1,2", -1),
+		Param("1,2,a", -1),
+		Param("1 2", -1),
+		Param("1,\n", -1),
+		Param("//;1;2", -1)
+	));

TDDKata/TestFixtureWithParam.h

@@ -0,0 +1,15 @@
+#pragma once
+#include "TestFixture.h"
+struct Param
+{
+    const char * expression;
+    int expected;
+    Param(const char * expression, int expected) :
+        expression(expression), expected(expected) {}
+};
+
+class TestFixtureWithParam :
+    public TestFixture, public ::testing::WithParamInterface<Param>
+{
+};
+

TDDKata/test.cpp

@@ -1,5 +1,165 @@
 #include "pch.h"
-	TEST(TDDKata, TestName) {
-		ASSERT_EQ(1, 1);
-		ASSERT_TRUE(true);
-	}
+#include "Calculator.h"
+#include "TestFixture.h"
+#include "TestFixtureWithParam.h"
+
+
+TEST_P(TestFixtureWithParam, Sets)
+{
+	const char* nums = GetParam().expression;
+	int expected = GetParam().expected;
+	// act
+	int actual = calc->Add(nums);
+	//assert
+	ASSERT_EQ(actual, expected);
+}
+/*
+TEST_F(TestFixture, PositiveUsual) {
+	// arrange
+	char* nums = "0,1,2";
+	int expected = 3;
+	// act
+	int actual = calc->Add(nums);
+	//assert
+	ASSERT_EQ(actual, expected);
+}
+
+TEST_F(TestFixture, PositiveZero) {
+	// arrange
+	char* nums = "0,0,0";
+	int expected = 0;
+	// act
+	int actual = calc->Add(nums);
+	//assert
+	ASSERT_EQ(actual, expected);
+}
+
+
+TEST_F(TestFixture, PositiveOne) {
+	// arrange
+	char* nums = "1";
+	int expected = 1;
+	// act
+	int actual = calc->Add(nums);
+	//assert
+
+	ASSERT_EQ(actual, expected);
+}
+
+TEST_F(TestFixture, PositiveTwo) {
+	// arrange
+	char* nums = "1,2";
+	int expected = 3;
+	// act
+	int actual = calc->Add(nums);
+	//assert
+
+	ASSERT_EQ(actual, expected);
+}
+
+TEST_F(TestFixture, PositiveEmpty) {
+	// arrange
+	char* nums = "";
+	int expected = 0;
+	// act
+	int actual = calc->Add(nums);
+	//assert
+
+	ASSERT_EQ(actual, expected);
+}
+
+TEST_F(TestFixture, NegativeNotNumAll) {
+	// arrange
+	char* nums = "abc";
+	int expected = -1;
+	// act
+	int actual = calc->Add(nums);
+	//assert
+
+	ASSERT_EQ(actual, expected);
+}
+
+TEST_F(TestFixture, NegativeNotNumOne) {
+	// arrange
+	char* nums = "a,1,2";
+	int expected = -1;
+	// act
+	int actual = calc->Add(nums);
+	//assert
+
+	ASSERT_EQ(actual, expected);
+}
+
+TEST_F(TestFixture, NegativeNotNumOneAtEnd) {
+	// arrange
+	char* nums = "1,2,a";
+	int expected = -1;
+	// act
+	int actual = calc->Add(nums);
+	//assert
+	ASSERT_EQ(actual, -1);
+}
+
+TEST_F(TestFixture, NegativeWrongSeparator) {
+	// arrange
+	char* nums = "1 2";
+	int expected = -1;
+	// act
+	int actual = calc->Add(nums);
+	//assert
+
+	ASSERT_EQ(actual, expected);
+}
+
+TEST_F(TestFixture, PositiveFewCountOfNumbers) {
+	// arrange
+	char* nums = "1,2,3,4,5,6";
+	int expected = 21;
+	// act
+	int actual = calc->Add(nums);
+	//assert
+	ASSERT_EQ(actual, expected);
+}
+
+TEST_F(TestFixture, PositiveNewLineSeparator) {
+	// arrange
+	char* nums = "1\n,2,3";
+	int expected = 6;
+	// act
+	int actual = calc->Add(nums);
+	//assert
+	ASSERT_EQ(actual, expected);
+}
+
+
+TEST_F(TestFixture, NegativeNewLineSeparator) {
+	// arrange
+	char* nums = "1,\n";
+	int expected = -1;
+	// act
+	int actual = calc->Add(nums);
+	//assert
+	ASSERT_EQ(actual, expected);
+}
+TEST_F(TestFixture, PositiveSetSeparator) {
+	// arrange
+	char* nums = "//;\n1;2";
+	int expected = 3;
+	// act
+	int actual = calc->Add(nums);
+	//assert
+
+	ASSERT_EQ(actual, expected);
+}
+
+TEST_F(TestFixture, NegativeSetSeparatorNoNeLine) {
+	// arrange
+	char* nums = "//;1;2";
+	int expected = -1;
+	// act
+	int actual = calc->Add(nums);
+	//assert
+
+	ASSERT_EQ(actual, expected);
+}
+*/