Add correctly assembled tests

ene02 · Aug 11, 2024 · c892180 · c892180
1 parent afc9ce0
commit c892180
Show file tree

Hide file tree

Showing 3 changed files with 214 additions and 0 deletions.
diff --git a/Calculator.Tests/Calculator.Tests.csproj b/Calculator.Tests/Calculator.Tests.csproj
@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="3.1.1" />
+    <PackageReference Include="MSTest.TestFramework" Version="3.1.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Calculator\Calculator.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Microsoft.VisualStudio.TestTools.UnitTesting" />
+  </ItemGroup>
+
+</Project>
diff --git a/Calculator.Tests/CalculatorTests.cs b/Calculator.Tests/CalculatorTests.cs
@@ -0,0 +1,181 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Calculator;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Calculator;
+
+namespace Calculator.Tests
+{
+    [TestClass()]
+    public class CalculatorTests
+    {
+        [TestMethod()]
+        public void IsNumberStringTrueTest()
+        {
+            Assert.IsTrue(Calculator.IsNumber("69"));
+            Assert.IsTrue(Calculator.IsNumber("69,9999"));
+            Assert.IsTrue(Calculator.IsNumber("-69"));
+            Assert.IsTrue(Calculator.IsNumber("-69,9999"));
+        }
+
+        [TestMethod()]
+        public void IsNumberCharTrueTest()
+        {
+            Assert.IsTrue(Calculator.IsNumber('9'));
+        }
+
+        public void IsNumberStringFalseTest()
+        {
+            Assert.IsFalse(Calculator.IsNumber("W"));
+        }
+
+        [TestMethod()]
+        public void IsNumberCharFalseTest()
+        {
+            Assert.IsFalse(Calculator.IsNumber('L'));
+        }
+
+        [TestMethod()]
+        public void GetSymbolTypeDefaultCharsTest()
+        {
+            Assert.AreEqual(Calculator.Symbol.Plus, Calculator.GetSymbolType('+'));
+            Assert.AreEqual(Calculator.Symbol.Minus, Calculator.GetSymbolType('-'));
+            Assert.AreEqual(Calculator.Symbol.Multiplication, Calculator.GetSymbolType('*'));
+            Assert.AreEqual(Calculator.Symbol.Division, Calculator.GetSymbolType('/'));
+            Assert.AreEqual(Calculator.Symbol.OpenParenthesis, Calculator.GetSymbolType('('));
+            Assert.AreEqual(Calculator.Symbol.CloseParenthesis, Calculator.GetSymbolType(')'));
+            Assert.AreEqual(Calculator.Symbol.Comma, Calculator.GetSymbolType(','));
+            Assert.AreEqual(Calculator.Symbol.Power, Calculator.GetSymbolType('^'));
+            Assert.AreEqual(Calculator.Symbol.Root, Calculator.GetSymbolType('#'));
+            Assert.AreEqual(Calculator.Symbol.Space, Calculator.GetSymbolType(' '));
+        }
+
+        [TestMethod()]
+        public void GetSymbolTypeDefaultStringsTest()
+        {
+            Assert.AreEqual(Calculator.Symbol.Plus, Calculator.GetSymbolType("+"));
+            Assert.AreEqual(Calculator.Symbol.Minus, Calculator.GetSymbolType("-"));
+            Assert.AreEqual(Calculator.Symbol.Multiplication, Calculator.GetSymbolType("*"));
+            Assert.AreEqual(Calculator.Symbol.Division, Calculator.GetSymbolType("/"));
+            Assert.AreEqual(Calculator.Symbol.OpenParenthesis, Calculator.GetSymbolType("("));
+            Assert.AreEqual(Calculator.Symbol.CloseParenthesis, Calculator.GetSymbolType(")"));
+            Assert.AreEqual(Calculator.Symbol.Comma, Calculator.GetSymbolType(","));
+            Assert.AreEqual(Calculator.Symbol.Power, Calculator.GetSymbolType("^"));
+            Assert.AreEqual(Calculator.Symbol.Root, Calculator.GetSymbolType("#"));
+            Assert.AreEqual(Calculator.Symbol.Space, Calculator.GetSymbolType(" "));
+        }
+
+        [TestMethod()]
+        public void GetSymbolTypeInvalidCharTest()
+        {
+            Assert.AreEqual(Calculator.Symbol.Invalid, Calculator.GetSymbolType('L'));
+        }
+
+        [TestMethod()]
+        public void GetSymbolTypeInvalidStringTest()
+        {
+            Assert.AreEqual(Calculator.Symbol.Invalid, Calculator.GetSymbolType("Nonsense"));
+            Assert.AreEqual(Calculator.Symbol.Invalid, Calculator.GetSymbolType("     "));
+        }
+
+        [TestMethod()]
+        public void SeparateTest()
+        {
+            string rawCalculation = "10,3+ 20-30*40/ (50^2,99999+(2#40,45) ) test";
+
+            List<string> expectedSeparation = ["10,3", "+", "20", "-", "30", "*", "40", "/", "(", "50", "^", "2,99999", "+", "(", "2", "#", "40,45", ")", ")", "test"];
+
+            List<string> actualSeparation = Calculator.Separate(rawCalculation);
+
+            for (int i = 0; i < expectedSeparation.Count(); i++)
+            {
+                if (expectedSeparation[i] != actualSeparation[i])
+                {
+                    Assert.Fail();
+                }
+            }
+        }
+
+        [TestMethod()]
+        public void IsSyntaxCorrectTrueTest()
+        {
+            string correctSyntaxOne = "10+20";
+            string correctSyntaxTwo = "10+20-30";
+            string correctSyntaxThree = "10+20-30*40";
+            string correctSyntaxFour = "10+20-30*40/50";
+            string correctSyntaxFive = "10+20-30*40/50^2";
+            string correctSyntaxSix = "10+20-30*40/50^2+(2#40)";
+            string correctSyntaxSeven = "10+20-30*40/(50^2+(2#40))";
+            string correctSyntaxEight = "10+20-(30*40)/(50^2+(2#40))";
+            string correctSyntaxNine = "(10+20)-(30*40)^2/(50^2+(2#40))#12";
+            string correctSyntaxTen = "10+(30^(23*2)/2)-(2#40/2)*30/3/(1+1*2)*(-10)";
+
+            Assert.IsTrue(Calculator.IsSyntaxCorrect(correctSyntaxOne));
+            Assert.IsTrue(Calculator.IsSyntaxCorrect(correctSyntaxTwo));
+            Assert.IsTrue(Calculator.IsSyntaxCorrect(correctSyntaxThree));
+            Assert.IsTrue(Calculator.IsSyntaxCorrect(correctSyntaxFour));
+            Assert.IsTrue(Calculator.IsSyntaxCorrect(correctSyntaxFive));
+            Assert.IsTrue(Calculator.IsSyntaxCorrect(correctSyntaxSix));
+            Assert.IsTrue(Calculator.IsSyntaxCorrect(correctSyntaxSeven));
+            Assert.IsTrue(Calculator.IsSyntaxCorrect(correctSyntaxEight));
+            Assert.IsTrue(Calculator.IsSyntaxCorrect(correctSyntaxNine));
+            Assert.IsTrue(Calculator.IsSyntaxCorrect(correctSyntaxTen));
+        }
+
+        [TestMethod()]
+        public void IsSyntaxCorrectFalseTest()
+        {
+            string badSyntaxOne = "10++";
+            string badSyntaxTwo = "+10+";
+            string badSyntaxThree = "10(+10)";
+            string badSyntaxFour = "10*+10";
+            string badSyntaxFive = "10++";
+            string badSyntaxSix = "10+30*45/(23+(1)";
+            string badSyntaxUnhinged = "((15+25)-(35*45)^3/(55^2+(3#60)#15+(20/5)^2*4#16)-(100#2+(30^3-(45#3)))^2/((7*9)+5^2*3)-(((6#36)+((8^3-2)^4#81)/(11+22))-((10^3-3)+(8^3-4)))/(18#81-((9#27)^2/3)+5^3)";
+
+            Assert.IsFalse(Calculator.IsSyntaxCorrect(badSyntaxOne));
+            Assert.IsFalse(Calculator.IsSyntaxCorrect(badSyntaxTwo));
+            Assert.IsFalse(Calculator.IsSyntaxCorrect(badSyntaxThree));
+            Assert.IsFalse(Calculator.IsSyntaxCorrect(badSyntaxFour));
+            Assert.IsFalse(Calculator.IsSyntaxCorrect(badSyntaxFive));
+            Assert.IsFalse(Calculator.IsSyntaxCorrect(badSyntaxSix));
+            Assert.IsFalse(Calculator.IsSyntaxCorrect(badSyntaxUnhinged));
+        }
+
+        [TestMethod()]
+        public void IsArimethicSymbolCharTrueTest()
+        {
+            Assert.IsTrue(Calculator.IsArimethicSymbol('+'));
+            Assert.IsTrue(Calculator.IsArimethicSymbol('-'));
+            Assert.IsTrue(Calculator.IsArimethicSymbol('*'));
+            Assert.IsTrue(Calculator.IsArimethicSymbol('/'));
+            Assert.IsTrue(Calculator.IsArimethicSymbol('^'));
+            Assert.IsTrue(Calculator.IsArimethicSymbol('#'));
+        }
+
+        [TestMethod()]
+        public void IsArimethicSymbolStringTrueTest()
+        {
+            Assert.IsTrue(Calculator.IsArimethicSymbol("+"));
+            Assert.IsTrue(Calculator.IsArimethicSymbol("-"));
+            Assert.IsTrue(Calculator.IsArimethicSymbol("*"));
+            Assert.IsTrue(Calculator.IsArimethicSymbol("/"));
+            Assert.IsTrue(Calculator.IsArimethicSymbol("^"));
+            Assert.IsTrue(Calculator.IsArimethicSymbol("#"));
+        }
+
+        [TestMethod()]
+        public void IsArimethicSymbolTrueTest()
+        {
+            Assert.IsTrue(Calculator.IsArimethicSymbol(Calculator.Symbol.Plus));
+            Assert.IsTrue(Calculator.IsArimethicSymbol(Calculator.Symbol.Minus));
+            Assert.IsTrue(Calculator.IsArimethicSymbol(Calculator.Symbol.Multiplication));
+            Assert.IsTrue(Calculator.IsArimethicSymbol(Calculator.Symbol.Division));
+            Assert.IsTrue(Calculator.IsArimethicSymbol(Calculator.Symbol.Power));
+            Assert.IsTrue(Calculator.IsArimethicSymbol(Calculator.Symbol.Root));
+        }
+    }
+}
diff --git a/Calculator.sln b/Calculator.sln
@@ -5,6 +5,8 @@ VisualStudioVersion = 17.10.35122.118
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Calculator", "Calculator\Calculator.csproj", "{FDB4C50E-5FB1-4A8E-B638-6AFC203483DB}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Calculator.Tests", "Calculator.Tests\Calculator.Tests.csproj", "{45E7CFE9-7D48-4061-B2E3-5C882EE53241}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -15,6 +17,10 @@ Global
 		{FDB4C50E-5FB1-4A8E-B638-6AFC203483DB}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{FDB4C50E-5FB1-4A8E-B638-6AFC203483DB}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{FDB4C50E-5FB1-4A8E-B638-6AFC203483DB}.Release|Any CPU.Build.0 = Release|Any CPU
+		{45E7CFE9-7D48-4061-B2E3-5C882EE53241}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{45E7CFE9-7D48-4061-B2E3-5C882EE53241}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{45E7CFE9-7D48-4061-B2E3-5C882EE53241}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{45E7CFE9-7D48-4061-B2E3-5C882EE53241}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE