From 3e33fb1b7353553b86288f85d13be81a724854ea Mon Sep 17 00:00:00 2001 From: MinyazevR Date: Mon, 28 Feb 2022 19:03:08 +0300 Subject: [PATCH 01/10] Writing basic stack functions, writing tests --- Stack/Stack.sln | 31 ++++++++++ Stack/Stack/Solution.cs | 9 +++ Stack/Stack/Stack.csproj | 10 ++++ Stack/Stack/StackOnArray.cs | 59 ++++++++++++++++++ Stack/Stack/StackOnLists.cs | 70 ++++++++++++++++++++++ Stack/TestStackOnArray/TestStack.csproj | 21 +++++++ Stack/TestStackOnArray/TestStackOnArray.cs | 55 +++++++++++++++++ Stack/TestStackOnArray/TestStackOnLists.cs | 55 +++++++++++++++++ 8 files changed, 310 insertions(+) create mode 100644 Stack/Stack.sln create mode 100644 Stack/Stack/Solution.cs create mode 100644 Stack/Stack/Stack.csproj create mode 100644 Stack/Stack/StackOnArray.cs create mode 100644 Stack/Stack/StackOnLists.cs create mode 100644 Stack/TestStackOnArray/TestStack.csproj create mode 100644 Stack/TestStackOnArray/TestStackOnArray.cs create mode 100644 Stack/TestStackOnArray/TestStackOnLists.cs diff --git a/Stack/Stack.sln b/Stack/Stack.sln new file mode 100644 index 0000000..69b9eb5 --- /dev/null +++ b/Stack/Stack.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.1.32210.238 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Stack", "Stack\Stack.csproj", "{70DCF9E2-593E-4AB9-A056-F0C172DA3419}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestStack", "TestStackOnArray\TestStack.csproj", "{60E6252B-6D54-47D9-B466-95927AFE6E5D}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {70DCF9E2-593E-4AB9-A056-F0C172DA3419}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {70DCF9E2-593E-4AB9-A056-F0C172DA3419}.Debug|Any CPU.Build.0 = Debug|Any CPU + {70DCF9E2-593E-4AB9-A056-F0C172DA3419}.Release|Any CPU.ActiveCfg = Release|Any CPU + {70DCF9E2-593E-4AB9-A056-F0C172DA3419}.Release|Any CPU.Build.0 = Release|Any CPU + {60E6252B-6D54-47D9-B466-95927AFE6E5D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {60E6252B-6D54-47D9-B466-95927AFE6E5D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {60E6252B-6D54-47D9-B466-95927AFE6E5D}.Release|Any CPU.ActiveCfg = Release|Any CPU + {60E6252B-6D54-47D9-B466-95927AFE6E5D}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {F2B1E14B-C1F7-471E-987B-DCCA99BA603E} + EndGlobalSection +EndGlobal diff --git a/Stack/Stack/Solution.cs b/Stack/Stack/Solution.cs new file mode 100644 index 0000000..01b00fc --- /dev/null +++ b/Stack/Stack/Solution.cs @@ -0,0 +1,9 @@ +namespace Stack; + +public class Solution +{ + static void Main() + { + return; + } +} diff --git a/Stack/Stack/Stack.csproj b/Stack/Stack/Stack.csproj new file mode 100644 index 0000000..74abf5c --- /dev/null +++ b/Stack/Stack/Stack.csproj @@ -0,0 +1,10 @@ + + + + Exe + net6.0 + enable + enable + + + diff --git a/Stack/Stack/StackOnArray.cs b/Stack/Stack/StackOnArray.cs new file mode 100644 index 0000000..7153ef2 --- /dev/null +++ b/Stack/Stack/StackOnArray.cs @@ -0,0 +1,59 @@ +using System; +using System.Collections.Generic; + +namespace Stack; + +public class StackOnArray +{ + private T[] values; + private int numberOfElements; + + public StackOnArray() + { + values = new T[20]; + } + + public bool IsEmpty() + { + return numberOfElements == 0; + } + + public void Push(T value) + { + if(numberOfElements == values.Length) + { + Array.Resize(ref values, values.Length + 20); + } + numberOfElements++; + values[numberOfElements - 1] = value; + } + + public T Pop() + { + if(numberOfElements == 0) + { + throw new InvalidOperationException("Stack is empty"); + } + T topOfSTack = values[numberOfElements - 1]; + numberOfElements--; + return topOfSTack; + } + + public T ReturnTopOfTheStack() + { + return values[numberOfElements - 1]; + } + + public int ReturnNumberOfElements() + { + return numberOfElements; + } + + public void PrintStack() + { + for (int i = 0; i < numberOfElements; i++) + { + Console.Write($"{values[i]} "); + } + } +} \ No newline at end of file diff --git a/Stack/Stack/StackOnLists.cs b/Stack/Stack/StackOnLists.cs new file mode 100644 index 0000000..5e505f5 --- /dev/null +++ b/Stack/Stack/StackOnLists.cs @@ -0,0 +1,70 @@ +using System; +using System.Collections.Generic; + +namespace Stack; + +public class StackOnLists +{ + private StackOnLists? head; + private StackOnLists? next; + private T? value; + private int numberOfElements; + + public bool IsEmpty() + { + return numberOfElements == 0; + } + + public void Push(T value) + { + numberOfElements++; + StackOnLists newHead = new StackOnLists(); + newHead.next = head; + head = newHead; + head.value = value; + } + + public T Pop() + { + if (head == null || head.value == null) + { + throw new InvalidOperationException("Stack is empty"); + } + var topOfSTack = head; + head = head.next; + numberOfElements--; + return topOfSTack.value; + } + + public int ReturnNumberOfElements() + { + return numberOfElements; + } + + public T ReturnTopOfTheStack() + { + if (head == null || head.value == null) + { + throw new InvalidOperationException("Stack is empty"); + } + return head.value; + } + + public void PrintStack() + { + if (head == null) + { + throw new InvalidOperationException("Stack is empty"); + } + StackOnLists copyHead = head; + while (copyHead != null && copyHead.next != null) + { + Console.Write($"{copyHead.value} "); + copyHead = copyHead.next; + } + if (copyHead != null && copyHead.value != null) + { + Console.Write($"{copyHead.value} "); + } + } +} diff --git a/Stack/TestStackOnArray/TestStack.csproj b/Stack/TestStackOnArray/TestStack.csproj new file mode 100644 index 0000000..48ef2ac --- /dev/null +++ b/Stack/TestStackOnArray/TestStack.csproj @@ -0,0 +1,21 @@ + + + + net6.0 + enable + + false + + + + + + + + + + + + + + diff --git a/Stack/TestStackOnArray/TestStackOnArray.cs b/Stack/TestStackOnArray/TestStackOnArray.cs new file mode 100644 index 0000000..73e9391 --- /dev/null +++ b/Stack/TestStackOnArray/TestStackOnArray.cs @@ -0,0 +1,55 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Stack; + +namespace TestStack; + +[TestClass] +public class TestStackOnArray +{ + [TestMethod] + public void TestPush() + { + StackOnArray stackOnArray = new StackOnArray(); + stackOnArray.Push(1); + Assert.AreEqual(stackOnArray.ReturnTopOfTheStack(), 1); + stackOnArray.Push(2); + Assert.AreEqual(stackOnArray.ReturnTopOfTheStack(), 2); + stackOnArray.Push(4); + Assert.AreEqual(stackOnArray.ReturnTopOfTheStack(), 4); + stackOnArray.Push(5); + Assert.AreEqual(stackOnArray.ReturnTopOfTheStack(), 5); + } + + [TestMethod] + public void TestPop() + { + StackOnArray stackOnArray = new StackOnArray(); + stackOnArray.Push("first"); + stackOnArray.Push("second"); + stackOnArray.Push("hello"); + stackOnArray.Push("kek"); + stackOnArray.Pop(); + Assert.AreEqual(stackOnArray.ReturnTopOfTheStack(), "hello"); + stackOnArray.Pop(); + Assert.AreEqual(stackOnArray.ReturnTopOfTheStack(), "second"); + stackOnArray.Pop(); + Assert.AreEqual(stackOnArray.ReturnTopOfTheStack(), "first"); + } + + [TestMethod] + public void TestReturnNumberOfElements() + { + StackOnArray stackOnArray = new StackOnArray(); + stackOnArray.Push("first"); + stackOnArray.Push("second"); + stackOnArray.Push("hello"); + stackOnArray.Push("kek"); + Assert.AreEqual(stackOnArray.ReturnNumberOfElements(), 4); + stackOnArray.Pop(); + Assert.AreEqual(stackOnArray.ReturnNumberOfElements(), 3); + stackOnArray.Pop(); + Assert.AreEqual(stackOnArray.ReturnNumberOfElements(), 2); + stackOnArray.Pop(); + Assert.AreEqual(stackOnArray.ReturnNumberOfElements(), 1); + } +} diff --git a/Stack/TestStackOnArray/TestStackOnLists.cs b/Stack/TestStackOnArray/TestStackOnLists.cs new file mode 100644 index 0000000..86f1b9f --- /dev/null +++ b/Stack/TestStackOnArray/TestStackOnLists.cs @@ -0,0 +1,55 @@ +using Microsoft.VisualStudio.TestTools.UnitTesting; +using Stack; + +namespace TestStack; + +[TestClass] +public class TestStackOnLists +{ + [TestMethod] + public void TestPush() + { + StackOnLists stackOnLists = new StackOnLists(); + stackOnLists.Push(1); + Assert.AreEqual(stackOnLists.ReturnTopOfTheStack(), 1); + stackOnLists.Push(2); + Assert.AreEqual(stackOnLists.ReturnTopOfTheStack(), 2); + stackOnLists.Push(4); + Assert.AreEqual(stackOnLists.ReturnTopOfTheStack(), 4); + stackOnLists.Push(5); + Assert.AreEqual(stackOnLists.ReturnTopOfTheStack(), 5); + } + + [TestMethod] + public void TestPop() + { + StackOnLists stackOnLists = new StackOnLists(); + stackOnLists.Push("first"); + stackOnLists.Push("second"); + stackOnLists.Push("hello"); + stackOnLists.Push("kek"); + stackOnLists.Pop(); + Assert.AreEqual(stackOnLists.ReturnTopOfTheStack(), "hello"); + stackOnLists.Pop(); + Assert.AreEqual(stackOnLists.ReturnTopOfTheStack(), "second"); + stackOnLists.Pop(); + Assert.AreEqual(stackOnLists.ReturnTopOfTheStack(), "first"); + } + + [TestMethod] + public void TestReturnNumberOfElements() + { + StackOnLists stackOnLists = new StackOnLists(); + stackOnLists.Push("first"); + stackOnLists.Push("second"); + stackOnLists.Push("hello"); + stackOnLists.Push("kek"); + Assert.AreEqual(stackOnLists.ReturnNumberOfElements(), 4); + stackOnLists.Pop(); + Assert.AreEqual(stackOnLists.ReturnNumberOfElements(), 3); + stackOnLists.Pop(); + Assert.AreEqual(stackOnLists.ReturnNumberOfElements(), 2); + stackOnLists.Pop(); + Assert.AreEqual(stackOnLists.ReturnNumberOfElements(), 1); + } +} From 8c940cf9b023d791779d1f43d011bae1d87cafdd Mon Sep 17 00:00:00 2001 From: MinyazevR Date: Sat, 2 Apr 2022 22:22:20 +0300 Subject: [PATCH 02/10] Rollback of commits due to their uninformativeness --- Homework2/StackCalculator/StackCalculator.sln | 37 ++++++ .../StackCalculator/Calculator.cs | 125 ++++++++++++++++++ .../StackCalculator/Solution.cs | 17 +++ .../StackCalculator/StackCalculator.csproj | 15 +++ .../StackCalculatorException.cs | 17 +++ .../TestStackCalculator.cs | 82 ++++++++++++ .../TestStackCalculator.csproj | 6 +- Stack/Stack.sln | 31 ----- Stack/Stack/IStack.cs | 47 +++++++ Stack/Stack/Solution.cs | 2 +- Stack/Stack/StackOnArray.cs | 78 ++++++++--- Stack/Stack/StackOnLists.cs | 113 ++++++++++------ Stack/StackTest/StackTest.cs | 103 +++++++++++++++ Stack/TestStackOnArray/TestStackOnArray.cs | 55 -------- Stack/TestStackOnArray/TestStackOnLists.cs | 55 -------- 15 files changed, 580 insertions(+), 203 deletions(-) create mode 100644 Homework2/StackCalculator/StackCalculator.sln create mode 100644 Homework2/StackCalculator/StackCalculator/Calculator.cs create mode 100644 Homework2/StackCalculator/StackCalculator/Solution.cs create mode 100644 Homework2/StackCalculator/StackCalculator/StackCalculator.csproj create mode 100644 Homework2/StackCalculator/StackCalculator/StackCalculatorException.cs create mode 100644 Homework2/StackCalculator/TestStackCalculator/TestStackCalculator.cs rename Stack/TestStackOnArray/TestStack.csproj => Homework2/StackCalculator/TestStackCalculator/TestStackCalculator.csproj (66%) delete mode 100644 Stack/Stack.sln create mode 100644 Stack/Stack/IStack.cs create mode 100644 Stack/StackTest/StackTest.cs delete mode 100644 Stack/TestStackOnArray/TestStackOnArray.cs delete mode 100644 Stack/TestStackOnArray/TestStackOnLists.cs diff --git a/Homework2/StackCalculator/StackCalculator.sln b/Homework2/StackCalculator/StackCalculator.sln new file mode 100644 index 0000000..9193f9c --- /dev/null +++ b/Homework2/StackCalculator/StackCalculator.sln @@ -0,0 +1,37 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.1.32210.238 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "StackCalculator", "StackCalculator\StackCalculator.csproj", "{8DBDDAE0-E403-49E6-9223-5AC9BF60294F}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestStackCalculator", "TestStackCalculator\TestStackCalculator.csproj", "{46FAACC4-DAD8-4735-943E-22F9ADAA23C6}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Stack", "..\..\Stack\Stack\Stack.csproj", "{C66F855E-3C30-4EA4-AFBC-87B64CBCB781}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {8DBDDAE0-E403-49E6-9223-5AC9BF60294F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {8DBDDAE0-E403-49E6-9223-5AC9BF60294F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {8DBDDAE0-E403-49E6-9223-5AC9BF60294F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {8DBDDAE0-E403-49E6-9223-5AC9BF60294F}.Release|Any CPU.Build.0 = Release|Any CPU + {46FAACC4-DAD8-4735-943E-22F9ADAA23C6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {46FAACC4-DAD8-4735-943E-22F9ADAA23C6}.Debug|Any CPU.Build.0 = Debug|Any CPU + {46FAACC4-DAD8-4735-943E-22F9ADAA23C6}.Release|Any CPU.ActiveCfg = Release|Any CPU + {46FAACC4-DAD8-4735-943E-22F9ADAA23C6}.Release|Any CPU.Build.0 = Release|Any CPU + {C66F855E-3C30-4EA4-AFBC-87B64CBCB781}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {C66F855E-3C30-4EA4-AFBC-87B64CBCB781}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C66F855E-3C30-4EA4-AFBC-87B64CBCB781}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C66F855E-3C30-4EA4-AFBC-87B64CBCB781}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {F3D2B963-4468-436F-A5AE-D78F83C046C7} + EndGlobalSection +EndGlobal diff --git a/Homework2/StackCalculator/StackCalculator/Calculator.cs b/Homework2/StackCalculator/StackCalculator/Calculator.cs new file mode 100644 index 0000000..a2399e8 --- /dev/null +++ b/Homework2/StackCalculator/StackCalculator/Calculator.cs @@ -0,0 +1,125 @@ +using System; +using Stack; + +namespace StackCalculator; + +/// +/// A class representing a stack calculator +/// +public class Calculator +{ + private IStack Stack = new StackOnLists(); + + /// + /// Function for counting expressions in postfix form + /// + /// Expression value + public float CountTheExpressionInPostfixForm(string[] inputString) + { + int number = 0; + for (int i = 0; i < inputString.Length; i++) + { + if (inputString[i] == "") + { + continue; + } + if (int.TryParse(inputString[i], out number)) + { + Stack.Push(number); + continue; + } + try + { + if (Stack.ReturnNumberOfElements() < 2) + { + throw new IncorrectExpressionException("Incorrect expression"); + } + } + catch (IncorrectExpressionException exception) + { + Console.WriteLine($"Ошибка: {exception.Message}"); + throw; + } + float secondNumber = 0; + float firstNumber = 0; + try + { + secondNumber = Stack.Pop(); + firstNumber = Stack.Pop(); + } + catch (StackException) + { + Console.WriteLine("Incorrect expression"); + throw; + } + if (inputString[i] == "+") + { + Stack.Push(firstNumber + secondNumber); + continue; + } + if (inputString[i] == "-") + { + Stack.Push(firstNumber - secondNumber); + continue; + } + if (inputString[i] == "*") + { + Stack.Push(firstNumber * secondNumber); + continue; + } + if (inputString[i] == "/") + { + try + { + if (secondNumber.CompareTo(0) == 0) + { + throw new DivideByZeroException("division by 0"); + } + } + catch (DivideByZeroException exception) + { + Console.WriteLine($"Ошибка: {exception.Message}"); + throw; + } + Stack.Push(firstNumber / secondNumber); + } + else + { + try + { + throw new InvalidCharacterException("Invalid character"); + } + catch(InvalidCharacterException exception) + { + Console.WriteLine($"Ошибка: {exception.Message}"); + throw; + } + } + } + try + { + if (Stack.ReturnNumberOfElements() > 1) + { + throw new IncorrectExpressionException("Incorrect expression"); + } + } + catch (IncorrectExpressionException exception) + { + Console.WriteLine($"Ошибка: {exception.Message}"); + throw; + } + try + { + if (Stack.ReturnNumberOfElements() < 1) + { + throw new IncorrectExpressionException("Empty string"); + } + } + catch (IncorrectExpressionException exception) + { + Console.WriteLine($"Ошибка: {exception.Message}"); + throw; + } + return Stack.Pop(); + } +} diff --git a/Homework2/StackCalculator/StackCalculator/Solution.cs b/Homework2/StackCalculator/StackCalculator/Solution.cs new file mode 100644 index 0000000..3fc24c8 --- /dev/null +++ b/Homework2/StackCalculator/StackCalculator/Solution.cs @@ -0,0 +1,17 @@ +namespace StackCalculator; + +public class Solution +{ + static void Main() + { + Console.WriteLine("Please, enter the expression"); + var inputString = Console.ReadLine(); + if (inputString == null) + { + return; + } + var subs = inputString.Split(' '); + Calculator stackCalculator = new Calculator(); + Console.WriteLine($"{stackCalculator.CountTheExpressionInPostfixForm(subs)}"); + } +} diff --git a/Homework2/StackCalculator/StackCalculator/StackCalculator.csproj b/Homework2/StackCalculator/StackCalculator/StackCalculator.csproj new file mode 100644 index 0000000..0f6d51a --- /dev/null +++ b/Homework2/StackCalculator/StackCalculator/StackCalculator.csproj @@ -0,0 +1,15 @@ + + + + Exe + net6.0 + enable + enable + + + + + + + + diff --git a/Homework2/StackCalculator/StackCalculator/StackCalculatorException.cs b/Homework2/StackCalculator/StackCalculator/StackCalculatorException.cs new file mode 100644 index 0000000..a586e70 --- /dev/null +++ b/Homework2/StackCalculator/StackCalculator/StackCalculatorException.cs @@ -0,0 +1,17 @@ +namespace StackCalculator; + +/// +/// A class for creating custom exceptions +/// +public class InvalidCharacterException : Exception +{ + public InvalidCharacterException(string? message) : base(message) { } +} + +/// +/// A class for creating custom exceptions +/// +public class IncorrectExpressionException : Exception +{ + public IncorrectExpressionException(string? message) : base(message) { } +} diff --git a/Homework2/StackCalculator/TestStackCalculator/TestStackCalculator.cs b/Homework2/StackCalculator/TestStackCalculator/TestStackCalculator.cs new file mode 100644 index 0000000..ac3ec9e --- /dev/null +++ b/Homework2/StackCalculator/TestStackCalculator/TestStackCalculator.cs @@ -0,0 +1,82 @@ +using NUnit.Framework; +using StackCalculator; +using System; + +namespace TestStackCalculator; + +/// +/// A class for testing a stack calculator +/// +public class TestsStackCalculator +{ + Calculator? stackCalculator; + [SetUp] + public void Setup() + { + stackCalculator = new Calculator(); + } + + [Test] + public void DevideByZero() + { + string[] firstArray = { "123", "0", "/" }; + Assert.Throws(() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray)); + } + + [Test] + public void ExpressionFromInvalidCharacter() + { + string[] firstArray = { "123", "0", "a" }; + Assert.Throws (() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray)); + } + + [Test] + public void FirstIncorrectExpression() + { + string[] firstArray = { "123", "4", "*", "-" }; + Assert.Throws(() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray)); + } + + [Test] + public void SecondIncorrectExpression() + { + string[] firstArray = { "123", "4", "9", "23", "*", "-" }; + Assert.Throws(() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray)); + } + + [Test] + public void ValidOneCharacterExpression() + { + string[] firstArray = { "12"}; + Assert.AreEqual(12, stackCalculator?.CountTheExpressionInPostfixForm(firstArray)); + } + + + [Test] + public void ValidExpressionFromZeros() + { + string[] firstArray = { "0", "0", "+", "0", "-" }; + Assert.AreEqual(0, stackCalculator?.CountTheExpressionInPostfixForm(firstArray)); + } + + [Test] + public void ExpressionWithoutNumbers() + { + string[] firstArray = {"+", "-"}; + Assert.Throws(() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray)); + } + + [Test] + public void EmptyString() + { + string[] firstArray = {" "}; + Assert.Throws(() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray)); + } + + [Test] + public void LongExpression() + { + string[] firstArray = { "0" , "120", "+", "45", "15", "/", "33", "+", "-5", "-13", "+", "9", "/", "/", "1", "123", "*", "+", "-" }; + Assert.AreEqual(15, stackCalculator?.CountTheExpressionInPostfixForm(firstArray)); + } +} \ No newline at end of file diff --git a/Stack/TestStackOnArray/TestStack.csproj b/Homework2/StackCalculator/TestStackCalculator/TestStackCalculator.csproj similarity index 66% rename from Stack/TestStackOnArray/TestStack.csproj rename to Homework2/StackCalculator/TestStackCalculator/TestStackCalculator.csproj index 48ef2ac..b7fe0be 100644 --- a/Stack/TestStackOnArray/TestStack.csproj +++ b/Homework2/StackCalculator/TestStackCalculator/TestStackCalculator.csproj @@ -9,13 +9,13 @@ - - + + - + diff --git a/Stack/Stack.sln b/Stack/Stack.sln deleted file mode 100644 index 69b9eb5..0000000 --- a/Stack/Stack.sln +++ /dev/null @@ -1,31 +0,0 @@ - -Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio Version 17 -VisualStudioVersion = 17.1.32210.238 -MinimumVisualStudioVersion = 10.0.40219.1 -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Stack", "Stack\Stack.csproj", "{70DCF9E2-593E-4AB9-A056-F0C172DA3419}" -EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestStack", "TestStackOnArray\TestStack.csproj", "{60E6252B-6D54-47D9-B466-95927AFE6E5D}" -EndProject -Global - GlobalSection(SolutionConfigurationPlatforms) = preSolution - Debug|Any CPU = Debug|Any CPU - Release|Any CPU = Release|Any CPU - EndGlobalSection - GlobalSection(ProjectConfigurationPlatforms) = postSolution - {70DCF9E2-593E-4AB9-A056-F0C172DA3419}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {70DCF9E2-593E-4AB9-A056-F0C172DA3419}.Debug|Any CPU.Build.0 = Debug|Any CPU - {70DCF9E2-593E-4AB9-A056-F0C172DA3419}.Release|Any CPU.ActiveCfg = Release|Any CPU - {70DCF9E2-593E-4AB9-A056-F0C172DA3419}.Release|Any CPU.Build.0 = Release|Any CPU - {60E6252B-6D54-47D9-B466-95927AFE6E5D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {60E6252B-6D54-47D9-B466-95927AFE6E5D}.Debug|Any CPU.Build.0 = Debug|Any CPU - {60E6252B-6D54-47D9-B466-95927AFE6E5D}.Release|Any CPU.ActiveCfg = Release|Any CPU - {60E6252B-6D54-47D9-B466-95927AFE6E5D}.Release|Any CPU.Build.0 = Release|Any CPU - EndGlobalSection - GlobalSection(SolutionProperties) = preSolution - HideSolutionNode = FALSE - EndGlobalSection - GlobalSection(ExtensibilityGlobals) = postSolution - SolutionGuid = {F2B1E14B-C1F7-471E-987B-DCCA99BA603E} - EndGlobalSection -EndGlobal diff --git a/Stack/Stack/IStack.cs b/Stack/Stack/IStack.cs new file mode 100644 index 0000000..7ab3c72 --- /dev/null +++ b/Stack/Stack/IStack.cs @@ -0,0 +1,47 @@ +namespace Stack; + +/// +/// A class representing the stack interface +/// +abstract public class IStack +{ + /// + /// Function for checking the stack for emptiness + /// + /// True - if the stack is empty + abstract public bool IsEmpty(); + + /// + /// Function for adding an element to the stack + /// + /// The value to add + abstract public void Push(T value); + + /// + /// Function for removing an element from the stack + /// + /// Remote value + abstract public T? Pop(); + + /// + /// Function that returns the number of elements in the stack + /// + /// Number of elements in stack + abstract public int ReturnNumberOfElements(); + + /// + /// Function that returns the top of the stack + /// + /// Top of the stack + abstract public T? ReturnTopOfTheStack(); + + /// + /// Function for stack printing + /// + abstract public void PrintStack(); + + /// + /// Function for removing the stack + /// + abstract public void DeleteStack(); +} diff --git a/Stack/Stack/Solution.cs b/Stack/Stack/Solution.cs index 01b00fc..943df28 100644 --- a/Stack/Stack/Solution.cs +++ b/Stack/Stack/Solution.cs @@ -4,6 +4,6 @@ public class Solution { static void Main() { - return; + } } diff --git a/Stack/Stack/StackOnArray.cs b/Stack/Stack/StackOnArray.cs index 7153ef2..35eab92 100644 --- a/Stack/Stack/StackOnArray.cs +++ b/Stack/Stack/StackOnArray.cs @@ -3,9 +3,12 @@ namespace Stack; -public class StackOnArray +/// +/// A class representing the stack on arrays +/// +public class StackOnArray : IStack { - private T[] values; + private T[]? values; private int numberOfElements; public StackOnArray() @@ -13,47 +16,80 @@ public StackOnArray() values = new T[20]; } - public bool IsEmpty() - { - return numberOfElements == 0; - } + /// + /// Function for checking the stack for emptiness + /// + /// True - if the stack is empty + public override bool IsEmpty() => numberOfElements == 0; - public void Push(T value) + /// + /// Function for adding an element to the stack + /// + /// The value to add + public override void Push(T value) { - if(numberOfElements == values.Length) + if (values != null && numberOfElements == values.Length) { Array.Resize(ref values, values.Length + 20); } numberOfElements++; + if (values == null) + { + return; + } values[numberOfElements - 1] = value; } - public T Pop() + /// + /// Function for removing an element from the stack + /// + /// Remote value + public override T Pop() { - if(numberOfElements == 0) + if (numberOfElements == 0 || values == null) { - throw new InvalidOperationException("Stack is empty"); + throw new StackException("Stack is empty"); } T topOfSTack = values[numberOfElements - 1]; numberOfElements--; return topOfSTack; } - public T ReturnTopOfTheStack() - { - return values[numberOfElements - 1]; - } - - public int ReturnNumberOfElements() + /// + /// Function that returns the top of the stack + /// + /// Top of the stack + public override T ReturnTopOfTheStack() { - return numberOfElements; + if (numberOfElements == 0 || values == null) + { + throw new StackException("Stack is empty"); + } + return values[numberOfElements - 1]; } - public void PrintStack() + /// + /// Function that returns the number of elements in the stack + /// + /// Number of elements in stack + public override int ReturnNumberOfElements() => numberOfElements; + + /// + /// Function for stack printing + /// + public override void PrintStack() { - for (int i = 0; i < numberOfElements; i++) + for (int i = numberOfElements - 1; i >= 0; i--) { - Console.Write($"{values[i]} "); + if (values != null) + { + Console.Write($"{values[i]} "); + } } } + + /// + /// Function for removing the stack + /// + public override void DeleteStack() => values = null; } \ No newline at end of file diff --git a/Stack/Stack/StackOnLists.cs b/Stack/Stack/StackOnLists.cs index 5e505f5..21e0046 100644 --- a/Stack/Stack/StackOnLists.cs +++ b/Stack/Stack/StackOnLists.cs @@ -3,68 +3,107 @@ namespace Stack; -public class StackOnLists +/// +/// A class for creating custom exceptions +/// +public class StackException : Exception { - private StackOnLists? head; - private StackOnLists? next; - private T? value; - private int numberOfElements; + public StackException(string? message) : base(message) { } +} - public bool IsEmpty() +/// +/// A class representing the stack on lists +/// +public class StackOnLists : IStack +{ + private class StackElement { - return numberOfElements == 0; + private StackElement? next { get; set; } + private T? value; + public T? Value { get => value; set { this.value = value; } } + public StackElement? Next { get => next; set { next = value; } } } - public void Push(T value) + private StackElement? head; + private int numberOfElements; + + /// + /// Function for checking the stack for emptiness + /// + /// True - if the stack is empty + public override bool IsEmpty() => numberOfElements == 0; + + /// + /// Function for adding an element to the stack + /// + /// The value to add + public override void Push(T value) { numberOfElements++; - StackOnLists newHead = new StackOnLists(); - newHead.next = head; + StackElement newHead = new StackElement(); + newHead.Value = value; + newHead.Next = head; head = newHead; - head.value = value; } - public T Pop() + /// + /// Function for removing an element from the stack + /// + /// Remote value + public override T? Pop() { - if (head == null || head.value == null) + if (head == null) + { + throw new StackException("Stack is empty"); + } + if (head != null) { - throw new InvalidOperationException("Stack is empty"); + T? value = head.Value; + head = head.Next; + numberOfElements--; + return value; } - var topOfSTack = head; - head = head.next; - numberOfElements--; - return topOfSTack.value; + return default(T); } - public int ReturnNumberOfElements() - { - return numberOfElements; - } + /// + /// Function that returns the number of elements in the stack + /// + /// Number of elements in stack + public override int ReturnNumberOfElements() => numberOfElements; - public T ReturnTopOfTheStack() + /// + /// Function that returns the top of the stack + /// + /// Top of the stack + public override T? ReturnTopOfTheStack() { - if (head == null || head.value == null) + if (head == null) { - throw new InvalidOperationException("Stack is empty"); + throw new StackException("Stack is empty"); } - return head.value; + return head == null ? default(T) : head.Value; } - public void PrintStack() + /// + /// Function for stack printing + /// + public override void PrintStack() { if (head == null) { - throw new InvalidOperationException("Stack is empty"); + return; } - StackOnLists copyHead = head; - while (copyHead != null && copyHead.next != null) + StackElement? copyHead = head; + while (copyHead != null) { - Console.Write($"{copyHead.value} "); - copyHead = copyHead.next; - } - if (copyHead != null && copyHead.value != null) - { - Console.Write($"{copyHead.value} "); + Console.Write($"{copyHead.Value} "); + copyHead = copyHead.Next; } } -} + + /// + /// Function for removing the stack + /// + public override void DeleteStack() => head = null; +} \ No newline at end of file diff --git a/Stack/StackTest/StackTest.cs b/Stack/StackTest/StackTest.cs new file mode 100644 index 0000000..0427683 --- /dev/null +++ b/Stack/StackTest/StackTest.cs @@ -0,0 +1,103 @@ +using NUnit.Framework; +using Stack; +using System.Collections.Generic; +using System; + +namespace StackTest; + +/// +/// A class for testing the stack on arrays +/// +public class StackTest +{ + private static IEnumerable Stacks + => new TestCaseData[] + { + new TestCaseData(new StackOnArray()), + new TestCaseData(new StackOnLists()), + }; + + [TestCaseSource(nameof(Stacks))] + public void RemoveElementFromEmptyStack(IStack stack) + { + var exception = Assert.Throws(() => stack?.Pop()); + } + + [TestCaseSource(nameof(Stacks))] + public void StackShouldNotEmptyAfterPush(IStack stack) + { + stack.Push(1); + Assert.IsFalse(stack.IsEmpty()); + } + + [TestCaseSource(nameof(Stacks))] + public void CheckTopOfEmptyStack(IStack stack) + { + var exception = Assert.Throws(() => stack?.ReturnTopOfTheStack()); + } + + [TestCaseSource(nameof(Stacks))] + public void CheckTopOfTheStackAfterPush(IStack stack) + { + stack?.Push(1); + Assert.AreEqual(stack?.ReturnTopOfTheStack(), 1); + } + + [TestCaseSource(nameof(Stacks))] + public void CheckNumberOfElementForEmptyStack(IStack stack) + { + Assert.AreEqual(stack?.ReturnNumberOfElements(), 0); + } + + [TestCaseSource(nameof(Stacks))] + public void CheckNumberOfElementAfterPush(IStack stack) + { + stack?.Push(1); + Assert.AreEqual(stack?.ReturnNumberOfElements(), 1); + } + + [TestCaseSource(nameof(Stacks))] + public void CheckNumberOfElementsAfterPushAfterPop(IStack stack) + { + stack?.Push(1); + Assert.AreEqual(stack?.ReturnNumberOfElements(), 1); + stack?.Pop(); + Assert.AreEqual(stack?.ReturnNumberOfElements(), 0); + } + + [TestCaseSource(nameof(Stacks))] + public void CheckNumberOfElementAfterPushPush(IStack stack) + { + stack?.Push(1); + Assert.AreEqual(stack?.ReturnNumberOfElements(), 1); + stack?.Push(2); + Assert.AreEqual(stack?.ReturnNumberOfElements(), 2); + } + + [TestCaseSource(nameof(Stacks))] + public void CheckTopOfTheStackAfterPushPushPop(IStack stack) + { + stack?.Push(1); + Assert.AreEqual(stack?.ReturnNumberOfElements(), 1); + stack?.Push(2); + stack?.Pop(); + Assert.AreEqual(stack?.ReturnNumberOfElements(), 1); + } + + [TestCaseSource(nameof(Stacks))] + public void CheckTopOfTheStackAfterPushPush(IStack stack) + { + stack?.Push(1); + stack?.Push(2); + Assert.AreEqual(stack?.ReturnTopOfTheStack(), 2); + } + + [TestCaseSource(nameof(Stacks))] + public void CheckPopAfterPrint(IStack stack) + { + stack?.Push(1); + stack?.Push(2); + stack?.PrintStack(); + Assert.AreEqual(stack?.ReturnTopOfTheStack(), 2); + } +} \ No newline at end of file diff --git a/Stack/TestStackOnArray/TestStackOnArray.cs b/Stack/TestStackOnArray/TestStackOnArray.cs deleted file mode 100644 index 73e9391..0000000 --- a/Stack/TestStackOnArray/TestStackOnArray.cs +++ /dev/null @@ -1,55 +0,0 @@ -using Microsoft.VisualStudio.TestTools.UnitTesting; -using Stack; - -namespace TestStack; - -[TestClass] -public class TestStackOnArray -{ - [TestMethod] - public void TestPush() - { - StackOnArray stackOnArray = new StackOnArray(); - stackOnArray.Push(1); - Assert.AreEqual(stackOnArray.ReturnTopOfTheStack(), 1); - stackOnArray.Push(2); - Assert.AreEqual(stackOnArray.ReturnTopOfTheStack(), 2); - stackOnArray.Push(4); - Assert.AreEqual(stackOnArray.ReturnTopOfTheStack(), 4); - stackOnArray.Push(5); - Assert.AreEqual(stackOnArray.ReturnTopOfTheStack(), 5); - } - - [TestMethod] - public void TestPop() - { - StackOnArray stackOnArray = new StackOnArray(); - stackOnArray.Push("first"); - stackOnArray.Push("second"); - stackOnArray.Push("hello"); - stackOnArray.Push("kek"); - stackOnArray.Pop(); - Assert.AreEqual(stackOnArray.ReturnTopOfTheStack(), "hello"); - stackOnArray.Pop(); - Assert.AreEqual(stackOnArray.ReturnTopOfTheStack(), "second"); - stackOnArray.Pop(); - Assert.AreEqual(stackOnArray.ReturnTopOfTheStack(), "first"); - } - - [TestMethod] - public void TestReturnNumberOfElements() - { - StackOnArray stackOnArray = new StackOnArray(); - stackOnArray.Push("first"); - stackOnArray.Push("second"); - stackOnArray.Push("hello"); - stackOnArray.Push("kek"); - Assert.AreEqual(stackOnArray.ReturnNumberOfElements(), 4); - stackOnArray.Pop(); - Assert.AreEqual(stackOnArray.ReturnNumberOfElements(), 3); - stackOnArray.Pop(); - Assert.AreEqual(stackOnArray.ReturnNumberOfElements(), 2); - stackOnArray.Pop(); - Assert.AreEqual(stackOnArray.ReturnNumberOfElements(), 1); - } -} diff --git a/Stack/TestStackOnArray/TestStackOnLists.cs b/Stack/TestStackOnArray/TestStackOnLists.cs deleted file mode 100644 index 86f1b9f..0000000 --- a/Stack/TestStackOnArray/TestStackOnLists.cs +++ /dev/null @@ -1,55 +0,0 @@ -using Microsoft.VisualStudio.TestTools.UnitTesting; -using Stack; - -namespace TestStack; - -[TestClass] -public class TestStackOnLists -{ - [TestMethod] - public void TestPush() - { - StackOnLists stackOnLists = new StackOnLists(); - stackOnLists.Push(1); - Assert.AreEqual(stackOnLists.ReturnTopOfTheStack(), 1); - stackOnLists.Push(2); - Assert.AreEqual(stackOnLists.ReturnTopOfTheStack(), 2); - stackOnLists.Push(4); - Assert.AreEqual(stackOnLists.ReturnTopOfTheStack(), 4); - stackOnLists.Push(5); - Assert.AreEqual(stackOnLists.ReturnTopOfTheStack(), 5); - } - - [TestMethod] - public void TestPop() - { - StackOnLists stackOnLists = new StackOnLists(); - stackOnLists.Push("first"); - stackOnLists.Push("second"); - stackOnLists.Push("hello"); - stackOnLists.Push("kek"); - stackOnLists.Pop(); - Assert.AreEqual(stackOnLists.ReturnTopOfTheStack(), "hello"); - stackOnLists.Pop(); - Assert.AreEqual(stackOnLists.ReturnTopOfTheStack(), "second"); - stackOnLists.Pop(); - Assert.AreEqual(stackOnLists.ReturnTopOfTheStack(), "first"); - } - - [TestMethod] - public void TestReturnNumberOfElements() - { - StackOnLists stackOnLists = new StackOnLists(); - stackOnLists.Push("first"); - stackOnLists.Push("second"); - stackOnLists.Push("hello"); - stackOnLists.Push("kek"); - Assert.AreEqual(stackOnLists.ReturnNumberOfElements(), 4); - stackOnLists.Pop(); - Assert.AreEqual(stackOnLists.ReturnNumberOfElements(), 3); - stackOnLists.Pop(); - Assert.AreEqual(stackOnLists.ReturnNumberOfElements(), 2); - stackOnLists.Pop(); - Assert.AreEqual(stackOnLists.ReturnNumberOfElements(), 1); - } -} From df38baa23d47ad5f1b1e52ba4af48a85a8231ef5 Mon Sep 17 00:00:00 2001 From: MinyazevR Date: Sun, 10 Apr 2022 21:46:08 +0300 Subject: [PATCH 03/10] --Changed working with exceptions --Each class in a separate file --Changed tests --The stack calculator class knows nothing about the stack implementation --- Homework2/StackCalculator/StackCalculator.sln | 8 +- .../StackCalculator/Calculator.cs | 86 +++++-------------- .../StackCalculator}/IStack.cs | 16 ++-- ...ion.cs => IncorrectExpressionException.cs} | 10 +-- .../InvalidCharacterException.cs | 9 ++ .../StackCalculator/Solution.cs | 17 ---- .../StackCalculator/StackCalculator.csproj | 6 +- .../StackCalculator/StackException.cs | 9 ++ .../StackCalculator}/StackOnArray.cs | 24 +++--- .../StackCalculator}/StackOnLists.cs | 41 ++++----- .../TestStackCalculator/TestStack.cs | 41 +++++---- .../TestStackCalculator.cs | 71 ++++++++------- ...estStackCalculator.csproj => Tests.csproj} | 0 Stack/Stack/Solution.cs | 9 -- Stack/Stack/Stack.csproj | 10 --- 15 files changed, 137 insertions(+), 220 deletions(-) rename {Stack/Stack => Homework2/StackCalculator/StackCalculator}/IStack.cs (75%) rename Homework2/StackCalculator/StackCalculator/{StackCalculatorException.cs => IncorrectExpressionException.cs} (53%) create mode 100644 Homework2/StackCalculator/StackCalculator/InvalidCharacterException.cs delete mode 100644 Homework2/StackCalculator/StackCalculator/Solution.cs create mode 100644 Homework2/StackCalculator/StackCalculator/StackException.cs rename {Stack/Stack => Homework2/StackCalculator/StackCalculator}/StackOnArray.cs (82%) rename {Stack/Stack => Homework2/StackCalculator/StackCalculator}/StackOnLists.cs (66%) rename Stack/StackTest/StackTest.cs => Homework2/StackCalculator/TestStackCalculator/TestStack.cs (70%) rename Homework2/StackCalculator/TestStackCalculator/{TestStackCalculator.csproj => Tests.csproj} (100%) delete mode 100644 Stack/Stack/Solution.cs delete mode 100644 Stack/Stack/Stack.csproj diff --git a/Homework2/StackCalculator/StackCalculator.sln b/Homework2/StackCalculator/StackCalculator.sln index 9193f9c..7317c0d 100644 --- a/Homework2/StackCalculator/StackCalculator.sln +++ b/Homework2/StackCalculator/StackCalculator.sln @@ -5,9 +5,7 @@ VisualStudioVersion = 17.1.32210.238 MinimumVisualStudioVersion = 10.0.40219.1 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "StackCalculator", "StackCalculator\StackCalculator.csproj", "{8DBDDAE0-E403-49E6-9223-5AC9BF60294F}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestStackCalculator", "TestStackCalculator\TestStackCalculator.csproj", "{46FAACC4-DAD8-4735-943E-22F9ADAA23C6}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Stack", "..\..\Stack\Stack\Stack.csproj", "{C66F855E-3C30-4EA4-AFBC-87B64CBCB781}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Tests", "TestStackCalculator\Tests.csproj", "{46FAACC4-DAD8-4735-943E-22F9ADAA23C6}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution @@ -23,10 +21,6 @@ Global {46FAACC4-DAD8-4735-943E-22F9ADAA23C6}.Debug|Any CPU.Build.0 = Debug|Any CPU {46FAACC4-DAD8-4735-943E-22F9ADAA23C6}.Release|Any CPU.ActiveCfg = Release|Any CPU {46FAACC4-DAD8-4735-943E-22F9ADAA23C6}.Release|Any CPU.Build.0 = Release|Any CPU - {C66F855E-3C30-4EA4-AFBC-87B64CBCB781}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {C66F855E-3C30-4EA4-AFBC-87B64CBCB781}.Debug|Any CPU.Build.0 = Debug|Any CPU - {C66F855E-3C30-4EA4-AFBC-87B64CBCB781}.Release|Any CPU.ActiveCfg = Release|Any CPU - {C66F855E-3C30-4EA4-AFBC-87B64CBCB781}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/Homework2/StackCalculator/StackCalculator/Calculator.cs b/Homework2/StackCalculator/StackCalculator/Calculator.cs index a2399e8..5e0811d 100644 --- a/Homework2/StackCalculator/StackCalculator/Calculator.cs +++ b/Homework2/StackCalculator/StackCalculator/Calculator.cs @@ -1,125 +1,81 @@ -using System; -using Stack; +namespace StackCalculator; -namespace StackCalculator; +using Stack; /// /// A class representing a stack calculator /// public class Calculator { - private IStack Stack = new StackOnLists(); - /// /// Function for counting expressions in postfix form /// /// Expression value - public float CountTheExpressionInPostfixForm(string[] inputString) + public float CountTheExpressionInPostfixForm(string[] inputString, IStack stack) { - int number = 0; for (int i = 0; i < inputString.Length; i++) { if (inputString[i] == "") { continue; } + int number = 0; if (int.TryParse(inputString[i], out number)) { - Stack.Push(number); + stack.Push(number); continue; } - try - { - if (Stack.ReturnNumberOfElements() < 2) - { - throw new IncorrectExpressionException("Incorrect expression"); - } - } - catch (IncorrectExpressionException exception) + if (stack.NumberOfElements() < 2) { - Console.WriteLine($"Ошибка: {exception.Message}"); - throw; + throw new IncorrectExpressionException(""); } float secondNumber = 0; float firstNumber = 0; try { - secondNumber = Stack.Pop(); - firstNumber = Stack.Pop(); + secondNumber = stack.Pop(); + firstNumber = stack.Pop(); } catch (StackException) { - Console.WriteLine("Incorrect expression"); throw; } if (inputString[i] == "+") { - Stack.Push(firstNumber + secondNumber); + stack.Push(firstNumber + secondNumber); continue; } if (inputString[i] == "-") { - Stack.Push(firstNumber - secondNumber); + stack.Push(firstNumber - secondNumber); continue; } if (inputString[i] == "*") { - Stack.Push(firstNumber * secondNumber); + stack.Push(firstNumber * secondNumber); continue; } if (inputString[i] == "/") { - try + if (Math.Abs(secondNumber - 0) < 0.0000000000000000000000000001) { - if (secondNumber.CompareTo(0) == 0) - { - throw new DivideByZeroException("division by 0"); - } + throw new DivideByZeroException(""); } - catch (DivideByZeroException exception) - { - Console.WriteLine($"Ошибка: {exception.Message}"); - throw; - } - Stack.Push(firstNumber / secondNumber); + stack.Push(firstNumber / secondNumber); } else { - try - { - throw new InvalidCharacterException("Invalid character"); - } - catch(InvalidCharacterException exception) - { - Console.WriteLine($"Ошибка: {exception.Message}"); - throw; - } + throw new InvalidCharacterException(""); } } - try + if (stack.NumberOfElements() > 1) { - if (Stack.ReturnNumberOfElements() > 1) - { - throw new IncorrectExpressionException("Incorrect expression"); - } - } - catch (IncorrectExpressionException exception) - { - Console.WriteLine($"Ошибка: {exception.Message}"); - throw; - } - try - { - if (Stack.ReturnNumberOfElements() < 1) - { - throw new IncorrectExpressionException("Empty string"); - } + throw new IncorrectExpressionException(""); } - catch (IncorrectExpressionException exception) + if (stack.NumberOfElements() < 1) { - Console.WriteLine($"Ошибка: {exception.Message}"); - throw; + throw new IncorrectExpressionException(""); } - return Stack.Pop(); + return stack.Pop(); } } diff --git a/Stack/Stack/IStack.cs b/Homework2/StackCalculator/StackCalculator/IStack.cs similarity index 75% rename from Stack/Stack/IStack.cs rename to Homework2/StackCalculator/StackCalculator/IStack.cs index 7ab3c72..7138d4d 100644 --- a/Stack/Stack/IStack.cs +++ b/Homework2/StackCalculator/StackCalculator/IStack.cs @@ -3,45 +3,45 @@ /// /// A class representing the stack interface /// -abstract public class IStack +public interface IStack { /// /// Function for checking the stack for emptiness /// /// True - if the stack is empty - abstract public bool IsEmpty(); + public bool IsEmpty(); /// /// Function for adding an element to the stack /// /// The value to add - abstract public void Push(T value); + public void Push(T value); /// /// Function for removing an element from the stack /// /// Remote value - abstract public T? Pop(); + public T? Pop(); /// /// Function that returns the number of elements in the stack /// /// Number of elements in stack - abstract public int ReturnNumberOfElements(); + public int NumberOfElements(); /// /// Function that returns the top of the stack /// /// Top of the stack - abstract public T? ReturnTopOfTheStack(); + public T? TopOfTheStack(); /// /// Function for stack printing /// - abstract public void PrintStack(); + public void PrintStack(); /// /// Function for removing the stack /// - abstract public void DeleteStack(); + public void ClearStack(); } diff --git a/Homework2/StackCalculator/StackCalculator/StackCalculatorException.cs b/Homework2/StackCalculator/StackCalculator/IncorrectExpressionException.cs similarity index 53% rename from Homework2/StackCalculator/StackCalculator/StackCalculatorException.cs rename to Homework2/StackCalculator/StackCalculator/IncorrectExpressionException.cs index a586e70..4d12cd8 100644 --- a/Homework2/StackCalculator/StackCalculator/StackCalculatorException.cs +++ b/Homework2/StackCalculator/StackCalculator/IncorrectExpressionException.cs @@ -1,17 +1,9 @@ namespace StackCalculator; -/// -/// A class for creating custom exceptions -/// -public class InvalidCharacterException : Exception -{ - public InvalidCharacterException(string? message) : base(message) { } -} - /// /// A class for creating custom exceptions /// public class IncorrectExpressionException : Exception { public IncorrectExpressionException(string? message) : base(message) { } -} +} \ No newline at end of file diff --git a/Homework2/StackCalculator/StackCalculator/InvalidCharacterException.cs b/Homework2/StackCalculator/StackCalculator/InvalidCharacterException.cs new file mode 100644 index 0000000..1ad94ff --- /dev/null +++ b/Homework2/StackCalculator/StackCalculator/InvalidCharacterException.cs @@ -0,0 +1,9 @@ +namespace StackCalculator; + +/// +/// A class for creating custom exceptions +/// +public class InvalidCharacterException : Exception +{ + public InvalidCharacterException(string? message) : base(message) { } +} \ No newline at end of file diff --git a/Homework2/StackCalculator/StackCalculator/Solution.cs b/Homework2/StackCalculator/StackCalculator/Solution.cs deleted file mode 100644 index 3fc24c8..0000000 --- a/Homework2/StackCalculator/StackCalculator/Solution.cs +++ /dev/null @@ -1,17 +0,0 @@ -namespace StackCalculator; - -public class Solution -{ - static void Main() - { - Console.WriteLine("Please, enter the expression"); - var inputString = Console.ReadLine(); - if (inputString == null) - { - return; - } - var subs = inputString.Split(' '); - Calculator stackCalculator = new Calculator(); - Console.WriteLine($"{stackCalculator.CountTheExpressionInPostfixForm(subs)}"); - } -} diff --git a/Homework2/StackCalculator/StackCalculator/StackCalculator.csproj b/Homework2/StackCalculator/StackCalculator/StackCalculator.csproj index 0f6d51a..a531813 100644 --- a/Homework2/StackCalculator/StackCalculator/StackCalculator.csproj +++ b/Homework2/StackCalculator/StackCalculator/StackCalculator.csproj @@ -1,15 +1,11 @@  - Exe + Library net6.0 enable enable - - - - diff --git a/Homework2/StackCalculator/StackCalculator/StackException.cs b/Homework2/StackCalculator/StackCalculator/StackException.cs new file mode 100644 index 0000000..03ccccb --- /dev/null +++ b/Homework2/StackCalculator/StackCalculator/StackException.cs @@ -0,0 +1,9 @@ +namespace Stack; + +/// +/// A class for creating custom exceptions +/// +public class StackException : Exception +{ + public StackException(string? message) : base(message) { } +} diff --git a/Stack/Stack/StackOnArray.cs b/Homework2/StackCalculator/StackCalculator/StackOnArray.cs similarity index 82% rename from Stack/Stack/StackOnArray.cs rename to Homework2/StackCalculator/StackCalculator/StackOnArray.cs index 35eab92..3a6f7fd 100644 --- a/Stack/Stack/StackOnArray.cs +++ b/Homework2/StackCalculator/StackCalculator/StackOnArray.cs @@ -1,14 +1,13 @@ -using System; -using System.Collections.Generic; +namespace Stack; -namespace Stack; +using System; /// /// A class representing the stack on arrays /// public class StackOnArray : IStack { - private T[]? values; + private T[] values; private int numberOfElements; public StackOnArray() @@ -20,13 +19,13 @@ public StackOnArray() /// Function for checking the stack for emptiness /// /// True - if the stack is empty - public override bool IsEmpty() => numberOfElements == 0; + public bool IsEmpty() => numberOfElements == 0; /// /// Function for adding an element to the stack /// /// The value to add - public override void Push(T value) + public void Push(T value) { if (values != null && numberOfElements == values.Length) { @@ -44,13 +43,14 @@ public override void Push(T value) /// Function for removing an element from the stack /// /// Remote value - public override T Pop() + public T Pop() { if (numberOfElements == 0 || values == null) { throw new StackException("Stack is empty"); } T topOfSTack = values[numberOfElements - 1]; + Array.Clear(values, numberOfElements - 1, 1); numberOfElements--; return topOfSTack; } @@ -59,7 +59,7 @@ public override T Pop() /// Function that returns the top of the stack /// /// Top of the stack - public override T ReturnTopOfTheStack() + public T TopOfTheStack() { if (numberOfElements == 0 || values == null) { @@ -72,12 +72,12 @@ public override T ReturnTopOfTheStack() /// Function that returns the number of elements in the stack /// /// Number of elements in stack - public override int ReturnNumberOfElements() => numberOfElements; + public int NumberOfElements() => numberOfElements; /// /// Function for stack printing /// - public override void PrintStack() + public void PrintStack() { for (int i = numberOfElements - 1; i >= 0; i--) { @@ -91,5 +91,5 @@ public override void PrintStack() /// /// Function for removing the stack /// - public override void DeleteStack() => values = null; -} \ No newline at end of file + public void ClearStack() => values = new T[20]; +} diff --git a/Stack/Stack/StackOnLists.cs b/Homework2/StackCalculator/StackCalculator/StackOnLists.cs similarity index 66% rename from Stack/Stack/StackOnLists.cs rename to Homework2/StackCalculator/StackCalculator/StackOnLists.cs index 21e0046..4fa75c0 100644 --- a/Stack/Stack/StackOnLists.cs +++ b/Homework2/StackCalculator/StackCalculator/StackOnLists.cs @@ -1,15 +1,6 @@ -using System; -using System.Collections.Generic; +namespace Stack; -namespace Stack; - -/// -/// A class for creating custom exceptions -/// -public class StackException : Exception -{ - public StackException(string? message) : base(message) { } -} +using System; /// /// A class representing the stack on lists @@ -18,10 +9,8 @@ public class StackOnLists : IStack { private class StackElement { - private StackElement? next { get; set; } - private T? value; - public T? Value { get => value; set { this.value = value; } } - public StackElement? Next { get => next; set { next = value; } } + public StackElement? Next { get; set; } + public T? Value { get; set; } } private StackElement? head; @@ -31,16 +20,16 @@ private class StackElement /// Function for checking the stack for emptiness /// /// True - if the stack is empty - public override bool IsEmpty() => numberOfElements == 0; + public bool IsEmpty() => numberOfElements == 0; /// /// Function for adding an element to the stack /// /// The value to add - public override void Push(T value) + public void Push(T value) { numberOfElements++; - StackElement newHead = new StackElement(); + StackElement newHead = new(); newHead.Value = value; newHead.Next = head; head = newHead; @@ -50,7 +39,7 @@ public override void Push(T value) /// Function for removing an element from the stack /// /// Remote value - public override T? Pop() + public T? Pop() { if (head == null) { @@ -63,32 +52,32 @@ public override void Push(T value) numberOfElements--; return value; } - return default(T); + return default; } /// /// Function that returns the number of elements in the stack /// /// Number of elements in stack - public override int ReturnNumberOfElements() => numberOfElements; + public int NumberOfElements() => numberOfElements; /// /// Function that returns the top of the stack /// /// Top of the stack - public override T? ReturnTopOfTheStack() + public T? TopOfTheStack() { if (head == null) { throw new StackException("Stack is empty"); } - return head == null ? default(T) : head.Value; + return head == null ? default : head.Value; } /// /// Function for stack printing /// - public override void PrintStack() + public void PrintStack() { if (head == null) { @@ -105,5 +94,5 @@ public override void PrintStack() /// /// Function for removing the stack /// - public override void DeleteStack() => head = null; -} \ No newline at end of file + public void ClearStack() => head = null; +} diff --git a/Stack/StackTest/StackTest.cs b/Homework2/StackCalculator/TestStackCalculator/TestStack.cs similarity index 70% rename from Stack/StackTest/StackTest.cs rename to Homework2/StackCalculator/TestStackCalculator/TestStack.cs index 0427683..d91b65f 100644 --- a/Stack/StackTest/StackTest.cs +++ b/Homework2/StackCalculator/TestStackCalculator/TestStack.cs @@ -1,9 +1,8 @@ +namespace TestStack; + using NUnit.Framework; using Stack; using System.Collections.Generic; -using System; - -namespace StackTest; /// /// A class for testing the stack on arrays @@ -11,11 +10,11 @@ namespace StackTest; public class StackTest { private static IEnumerable Stacks - => new TestCaseData[] - { - new TestCaseData(new StackOnArray()), - new TestCaseData(new StackOnLists()), - }; + => new TestCaseData[] + { + new TestCaseData(new StackOnArray()), + new TestCaseData(new StackOnLists()), + }; [TestCaseSource(nameof(Stacks))] public void RemoveElementFromEmptyStack(IStack stack) @@ -33,55 +32,55 @@ public void StackShouldNotEmptyAfterPush(IStack stack) [TestCaseSource(nameof(Stacks))] public void CheckTopOfEmptyStack(IStack stack) { - var exception = Assert.Throws(() => stack?.ReturnTopOfTheStack()); + var exception = Assert.Throws(() => stack?.TopOfTheStack()); } [TestCaseSource(nameof(Stacks))] public void CheckTopOfTheStackAfterPush(IStack stack) { stack?.Push(1); - Assert.AreEqual(stack?.ReturnTopOfTheStack(), 1); + Assert.AreEqual(stack?.TopOfTheStack(), 1); } [TestCaseSource(nameof(Stacks))] public void CheckNumberOfElementForEmptyStack(IStack stack) { - Assert.AreEqual(stack?.ReturnNumberOfElements(), 0); + Assert.AreEqual(stack?.NumberOfElements(), 0); } [TestCaseSource(nameof(Stacks))] public void CheckNumberOfElementAfterPush(IStack stack) { stack?.Push(1); - Assert.AreEqual(stack?.ReturnNumberOfElements(), 1); + Assert.AreEqual(stack?.NumberOfElements(), 1); } [TestCaseSource(nameof(Stacks))] public void CheckNumberOfElementsAfterPushAfterPop(IStack stack) { stack?.Push(1); - Assert.AreEqual(stack?.ReturnNumberOfElements(), 1); + Assert.AreEqual(stack?.NumberOfElements(), 1); stack?.Pop(); - Assert.AreEqual(stack?.ReturnNumberOfElements(), 0); + Assert.AreEqual(stack?.NumberOfElements(), 0); } [TestCaseSource(nameof(Stacks))] public void CheckNumberOfElementAfterPushPush(IStack stack) { stack?.Push(1); - Assert.AreEqual(stack?.ReturnNumberOfElements(), 1); + Assert.AreEqual(stack?.NumberOfElements(), 1); stack?.Push(2); - Assert.AreEqual(stack?.ReturnNumberOfElements(), 2); + Assert.AreEqual(stack?.NumberOfElements(), 2); } [TestCaseSource(nameof(Stacks))] public void CheckTopOfTheStackAfterPushPushPop(IStack stack) { stack?.Push(1); - Assert.AreEqual(stack?.ReturnNumberOfElements(), 1); + Assert.AreEqual(stack?.NumberOfElements(), 1); stack?.Push(2); stack?.Pop(); - Assert.AreEqual(stack?.ReturnNumberOfElements(), 1); + Assert.AreEqual(stack?.NumberOfElements(), 1); } [TestCaseSource(nameof(Stacks))] @@ -89,7 +88,7 @@ public void CheckTopOfTheStackAfterPushPush(IStack stack) { stack?.Push(1); stack?.Push(2); - Assert.AreEqual(stack?.ReturnTopOfTheStack(), 2); + Assert.AreEqual(stack?.TopOfTheStack(), 2); } [TestCaseSource(nameof(Stacks))] @@ -98,6 +97,6 @@ public void CheckPopAfterPrint(IStack stack) stack?.Push(1); stack?.Push(2); stack?.PrintStack(); - Assert.AreEqual(stack?.ReturnTopOfTheStack(), 2); + Assert.AreEqual(stack?.TopOfTheStack(), 2); } -} \ No newline at end of file +} diff --git a/Homework2/StackCalculator/TestStackCalculator/TestStackCalculator.cs b/Homework2/StackCalculator/TestStackCalculator/TestStackCalculator.cs index ac3ec9e..eb3d7ed 100644 --- a/Homework2/StackCalculator/TestStackCalculator/TestStackCalculator.cs +++ b/Homework2/StackCalculator/TestStackCalculator/TestStackCalculator.cs @@ -1,82 +1,91 @@ +namespace TestStackCalculator; + using NUnit.Framework; +using Stack; +using System.Collections.Generic; using StackCalculator; -using System; - -namespace TestStackCalculator; /// /// A class for testing a stack calculator /// public class TestsStackCalculator { - Calculator? stackCalculator; + private Calculator stackCalculator = new(); + [SetUp] public void Setup() { stackCalculator = new Calculator(); } - [Test] - public void DevideByZero() + private static IEnumerable Stacks + => new TestCaseData[] + { + new TestCaseData(new StackOnArray()), + new TestCaseData(new StackOnLists()), + }; + + [TestCaseSource(nameof(Stacks))] + public void DevideByZero(IStack stack) { string[] firstArray = { "123", "0", "/" }; - Assert.Throws(() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray)); + Assert.Throws(() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray, stack)); } - [Test] - public void ExpressionFromInvalidCharacter() + [TestCaseSource(nameof(Stacks))] + public void ExpressionFromInvalidCharacter(IStack stack) { string[] firstArray = { "123", "0", "a" }; - Assert.Throws (() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray)); + Assert.Throws (() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray, stack)); } - [Test] - public void FirstIncorrectExpression() + [TestCaseSource(nameof(Stacks))] + public void FirstIncorrectExpression(IStack stack) { string[] firstArray = { "123", "4", "*", "-" }; - Assert.Throws(() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray)); + Assert.Throws(() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray, stack)); } - [Test] - public void SecondIncorrectExpression() + [TestCaseSource(nameof(Stacks))] + public void SecondIncorrectExpression(IStack stack) { string[] firstArray = { "123", "4", "9", "23", "*", "-" }; - Assert.Throws(() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray)); + Assert.Throws(() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray, stack)); } - [Test] - public void ValidOneCharacterExpression() + [TestCaseSource(nameof(Stacks))] + public void ValidOneCharacterExpression(IStack stack) { string[] firstArray = { "12"}; - Assert.AreEqual(12, stackCalculator?.CountTheExpressionInPostfixForm(firstArray)); + Assert.AreEqual(12, stackCalculator?.CountTheExpressionInPostfixForm(firstArray, stack)); } - [Test] - public void ValidExpressionFromZeros() + [TestCaseSource(nameof(Stacks))] + public void ValidExpressionFromZeros(IStack stack) { string[] firstArray = { "0", "0", "+", "0", "-" }; - Assert.AreEqual(0, stackCalculator?.CountTheExpressionInPostfixForm(firstArray)); + Assert.AreEqual(0, stackCalculator?.CountTheExpressionInPostfixForm(firstArray, stack)); } - [Test] - public void ExpressionWithoutNumbers() + [TestCaseSource(nameof(Stacks))] + public void ExpressionWithoutNumbers(IStack stack) { string[] firstArray = {"+", "-"}; - Assert.Throws(() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray)); + Assert.Throws(() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray, stack)); } - [Test] - public void EmptyString() + [TestCaseSource(nameof(Stacks))] + public void EmptyString(IStack stack) { string[] firstArray = {" "}; - Assert.Throws(() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray)); + Assert.Throws(() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray, stack)); } - [Test] - public void LongExpression() + [TestCaseSource(nameof(Stacks))] + public void LongExpression(IStack stack) { string[] firstArray = { "0" , "120", "+", "45", "15", "/", "33", "+", "-5", "-13", "+", "9", "/", "/", "1", "123", "*", "+", "-" }; - Assert.AreEqual(15, stackCalculator?.CountTheExpressionInPostfixForm(firstArray)); + Assert.AreEqual(15, stackCalculator?.CountTheExpressionInPostfixForm(firstArray, stack)); } } \ No newline at end of file diff --git a/Homework2/StackCalculator/TestStackCalculator/TestStackCalculator.csproj b/Homework2/StackCalculator/TestStackCalculator/Tests.csproj similarity index 100% rename from Homework2/StackCalculator/TestStackCalculator/TestStackCalculator.csproj rename to Homework2/StackCalculator/TestStackCalculator/Tests.csproj diff --git a/Stack/Stack/Solution.cs b/Stack/Stack/Solution.cs deleted file mode 100644 index 943df28..0000000 --- a/Stack/Stack/Solution.cs +++ /dev/null @@ -1,9 +0,0 @@ -namespace Stack; - -public class Solution -{ - static void Main() - { - - } -} diff --git a/Stack/Stack/Stack.csproj b/Stack/Stack/Stack.csproj deleted file mode 100644 index 74abf5c..0000000 --- a/Stack/Stack/Stack.csproj +++ /dev/null @@ -1,10 +0,0 @@ - - - - Exe - net6.0 - enable - enable - - - From ffa58998a897fa9df3f1fcfa7d34bcb0019c167d Mon Sep 17 00:00:00 2001 From: MinyazevR Date: Sun, 10 Apr 2022 23:47:03 +0300 Subject: [PATCH 04/10] Changed function names in tests --- .../StackCalculator/Calculator.cs | 56 +++++++++---------- .../TestStackCalculator/TestStack.cs | 54 +++++------------- .../TestStackCalculator.cs | 27 ++++----- 3 files changed, 52 insertions(+), 85 deletions(-) diff --git a/Homework2/StackCalculator/StackCalculator/Calculator.cs b/Homework2/StackCalculator/StackCalculator/Calculator.cs index 5e0811d..af88f66 100644 --- a/Homework2/StackCalculator/StackCalculator/Calculator.cs +++ b/Homework2/StackCalculator/StackCalculator/Calculator.cs @@ -40,39 +40,39 @@ public float CountTheExpressionInPostfixForm(string[] inputString, IStack { throw; } - if (inputString[i] == "+") + switch (inputString[i]) { - stack.Push(firstNumber + secondNumber); - continue; - } - if (inputString[i] == "-") - { - stack.Push(firstNumber - secondNumber); - continue; - } - if (inputString[i] == "*") - { - stack.Push(firstNumber * secondNumber); - continue; - } - if (inputString[i] == "/") - { - if (Math.Abs(secondNumber - 0) < 0.0000000000000000000000000001) + case "+" : { - throw new DivideByZeroException(""); + stack.Push(firstNumber + secondNumber); + break; + } + case "-" : + { + stack.Push(firstNumber - secondNumber); + break; + } + case "*" : + { + stack.Push(firstNumber * secondNumber); + break; + } + case "/" : + { + if (Math.Abs(secondNumber - 0) < 0.0000000000000000000000000001) + { + throw new DivideByZeroException(""); + } + stack.Push(firstNumber / secondNumber); + break; + } + default : + { + throw new InvalidCharacterException(""); } - stack.Push(firstNumber / secondNumber); - } - else - { - throw new InvalidCharacterException(""); } } - if (stack.NumberOfElements() > 1) - { - throw new IncorrectExpressionException(""); - } - if (stack.NumberOfElements() < 1) + if (stack.NumberOfElements() != 1) { throw new IncorrectExpressionException(""); } diff --git a/Homework2/StackCalculator/TestStackCalculator/TestStack.cs b/Homework2/StackCalculator/TestStackCalculator/TestStack.cs index d91b65f..aa449a0 100644 --- a/Homework2/StackCalculator/TestStackCalculator/TestStack.cs +++ b/Homework2/StackCalculator/TestStackCalculator/TestStack.cs @@ -17,86 +17,60 @@ private static IEnumerable Stacks }; [TestCaseSource(nameof(Stacks))] - public void RemoveElementFromEmptyStack(IStack stack) + public void ShouldThrowsStackExceptionWhenRemoveFromEmptyStack(IStack stack) { var exception = Assert.Throws(() => stack?.Pop()); } [TestCaseSource(nameof(Stacks))] - public void StackShouldNotEmptyAfterPush(IStack stack) + public void ShouldStackNotEmptyAfterPush(IStack stack) { stack.Push(1); Assert.IsFalse(stack.IsEmpty()); } [TestCaseSource(nameof(Stacks))] - public void CheckTopOfEmptyStack(IStack stack) + public void ShouldThrowsStackExceptionWhenTopOfTheStackFromEmptyStack(IStack stack) { var exception = Assert.Throws(() => stack?.TopOfTheStack()); } [TestCaseSource(nameof(Stacks))] - public void CheckTopOfTheStackAfterPush(IStack stack) + public void ShouldTopOfTheStackEqual1WhenPush1(IStack stack) { stack?.Push(1); - Assert.AreEqual(stack?.TopOfTheStack(), 1); + Assert.AreEqual(1, stack?.TopOfTheStack()); } [TestCaseSource(nameof(Stacks))] - public void CheckNumberOfElementForEmptyStack(IStack stack) + public void ShouldNumberOFElementsEqualZeroWhenEmptyStack(IStack stack) { - Assert.AreEqual(stack?.NumberOfElements(), 0); + Assert.AreEqual(0, stack?.NumberOfElements()); } [TestCaseSource(nameof(Stacks))] - public void CheckNumberOfElementAfterPush(IStack stack) + public void ShouldNumberOfElementsEqual1WhenPushInEmptyStack(IStack stack) { stack?.Push(1); - Assert.AreEqual(stack?.NumberOfElements(), 1); + Assert.AreEqual(1, stack?.NumberOfElements()); } [TestCaseSource(nameof(Stacks))] - public void CheckNumberOfElementsAfterPushAfterPop(IStack stack) + public void ShouldNumberOfElementsNotChangesWhenRemoveAfterPush(IStack stack) { stack?.Push(1); - Assert.AreEqual(stack?.NumberOfElements(), 1); + Assert.AreEqual(1, stack?.NumberOfElements()); stack?.Pop(); - Assert.AreEqual(stack?.NumberOfElements(), 0); + Assert.AreEqual(0, stack?.NumberOfElements()); } - [TestCaseSource(nameof(Stacks))] - public void CheckNumberOfElementAfterPushPush(IStack stack) - { - stack?.Push(1); - Assert.AreEqual(stack?.NumberOfElements(), 1); - stack?.Push(2); - Assert.AreEqual(stack?.NumberOfElements(), 2); - } - - [TestCaseSource(nameof(Stacks))] - public void CheckTopOfTheStackAfterPushPushPop(IStack stack) - { - stack?.Push(1); - Assert.AreEqual(stack?.NumberOfElements(), 1); - stack?.Push(2); - stack?.Pop(); - Assert.AreEqual(stack?.NumberOfElements(), 1); - } - - [TestCaseSource(nameof(Stacks))] - public void CheckTopOfTheStackAfterPushPush(IStack stack) - { - stack?.Push(1); - stack?.Push(2); - Assert.AreEqual(stack?.TopOfTheStack(), 2); - } [TestCaseSource(nameof(Stacks))] - public void CheckPopAfterPrint(IStack stack) + public void ShouldTopOfTheStackNotChangesWhenPrintStack(IStack stack) { stack?.Push(1); stack?.Push(2); stack?.PrintStack(); - Assert.AreEqual(stack?.TopOfTheStack(), 2); + Assert.AreEqual(2, stack?.TopOfTheStack()); } } diff --git a/Homework2/StackCalculator/TestStackCalculator/TestStackCalculator.cs b/Homework2/StackCalculator/TestStackCalculator/TestStackCalculator.cs index eb3d7ed..03b471f 100644 --- a/Homework2/StackCalculator/TestStackCalculator/TestStackCalculator.cs +++ b/Homework2/StackCalculator/TestStackCalculator/TestStackCalculator.cs @@ -26,64 +26,57 @@ private static IEnumerable Stacks }; [TestCaseSource(nameof(Stacks))] - public void DevideByZero(IStack stack) + public void ShouldThrowsDivideByZeroExceptionWhenDivideByZero(IStack stack) { string[] firstArray = { "123", "0", "/" }; Assert.Throws(() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray, stack)); } [TestCaseSource(nameof(Stacks))] - public void ExpressionFromInvalidCharacter(IStack stack) + public void ShouldThrowsInvalidCharacterExceptionWhenExpressionContainsInvalidCharacter(IStack stack) { string[] firstArray = { "123", "0", "a" }; Assert.Throws (() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray, stack)); } [TestCaseSource(nameof(Stacks))] - public void FirstIncorrectExpression(IStack stack) + public void ShouldThrowsIncorrectExpressionExceptionWhenExpressionIncorrect(IStack stack) { - string[] firstArray = { "123", "4", "*", "-" }; - Assert.Throws(() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray, stack)); + string[] expression = { "123", "4", "*", "-" }; + Assert.Throws(() => stackCalculator?.CountTheExpressionInPostfixForm(expression, stack)); } - [TestCaseSource(nameof(Stacks))] - public void SecondIncorrectExpression(IStack stack) - { - string[] firstArray = { "123", "4", "9", "23", "*", "-" }; - Assert.Throws(() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray, stack)); - } [TestCaseSource(nameof(Stacks))] - public void ValidOneCharacterExpression(IStack stack) + public void ShouldExpected12WhenExpressionEqual12(IStack stack) { string[] firstArray = { "12"}; Assert.AreEqual(12, stackCalculator?.CountTheExpressionInPostfixForm(firstArray, stack)); } - [TestCaseSource(nameof(Stacks))] - public void ValidExpressionFromZeros(IStack stack) + public void ShouldExpectedZeroWhenExpressionContainsOnlyZerosAndNotContainsDivisions(IStack stack) { string[] firstArray = { "0", "0", "+", "0", "-" }; Assert.AreEqual(0, stackCalculator?.CountTheExpressionInPostfixForm(firstArray, stack)); } [TestCaseSource(nameof(Stacks))] - public void ExpressionWithoutNumbers(IStack stack) + public void ShouldThrowsIncorrectExpressionExceptionWhenExpressionContainsOnlyOperators(IStack stack) { string[] firstArray = {"+", "-"}; Assert.Throws(() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray, stack)); } [TestCaseSource(nameof(Stacks))] - public void EmptyString(IStack stack) + public void ShouldThrowsIncorrectExpressionExceptionWhenExpressionIsEmptyString(IStack stack) { string[] firstArray = {" "}; Assert.Throws(() => stackCalculator?.CountTheExpressionInPostfixForm(firstArray, stack)); } [TestCaseSource(nameof(Stacks))] - public void LongExpression(IStack stack) + public void ShouldExpected15WhenIfIsKnownThatTheResultIs15(IStack stack) { string[] firstArray = { "0" , "120", "+", "45", "15", "/", "33", "+", "-5", "-13", "+", "9", "/", "/", "1", "123", "*", "+", "-" }; Assert.AreEqual(15, stackCalculator?.CountTheExpressionInPostfixForm(firstArray, stack)); From 5cefc289d24ee81a3d48ab04ff2e2120c5ca80ab Mon Sep 17 00:00:00 2001 From: MinyazevR Date: Mon, 11 Apr 2022 20:56:27 +0300 Subject: [PATCH 05/10] Removed unnecessary messages in exceptions --- .../StackCalculator/StackCalculator/Calculator.cs | 10 +++++----- .../StackCalculator/IncorrectExpressionException.cs | 2 +- .../StackCalculator/InvalidCharacterException.cs | 2 +- .../StackCalculator/StackCalculator/StackException.cs | 9 --------- .../StackCalculator/StackIsEmptyException.cs | 9 +++++++++ .../StackCalculator/StackCalculator/StackOnArray.cs | 4 ++-- .../StackCalculator/StackCalculator/StackOnLists.cs | 4 ++-- .../StackCalculator/TestStackCalculator/TestStack.cs | 4 ++-- 8 files changed, 22 insertions(+), 22 deletions(-) delete mode 100644 Homework2/StackCalculator/StackCalculator/StackException.cs create mode 100644 Homework2/StackCalculator/StackCalculator/StackIsEmptyException.cs diff --git a/Homework2/StackCalculator/StackCalculator/Calculator.cs b/Homework2/StackCalculator/StackCalculator/Calculator.cs index af88f66..ab53048 100644 --- a/Homework2/StackCalculator/StackCalculator/Calculator.cs +++ b/Homework2/StackCalculator/StackCalculator/Calculator.cs @@ -27,7 +27,7 @@ public float CountTheExpressionInPostfixForm(string[] inputString, IStack } if (stack.NumberOfElements() < 2) { - throw new IncorrectExpressionException(""); + throw new IncorrectExpressionException(); } float secondNumber = 0; float firstNumber = 0; @@ -36,7 +36,7 @@ public float CountTheExpressionInPostfixForm(string[] inputString, IStack secondNumber = stack.Pop(); firstNumber = stack.Pop(); } - catch (StackException) + catch (StackIsEmptyException) { throw; } @@ -61,20 +61,20 @@ public float CountTheExpressionInPostfixForm(string[] inputString, IStack { if (Math.Abs(secondNumber - 0) < 0.0000000000000000000000000001) { - throw new DivideByZeroException(""); + throw new DivideByZeroException(); } stack.Push(firstNumber / secondNumber); break; } default : { - throw new InvalidCharacterException(""); + throw new InvalidCharacterException(); } } } if (stack.NumberOfElements() != 1) { - throw new IncorrectExpressionException(""); + throw new IncorrectExpressionException(); } return stack.Pop(); } diff --git a/Homework2/StackCalculator/StackCalculator/IncorrectExpressionException.cs b/Homework2/StackCalculator/StackCalculator/IncorrectExpressionException.cs index 4d12cd8..3a68f0e 100644 --- a/Homework2/StackCalculator/StackCalculator/IncorrectExpressionException.cs +++ b/Homework2/StackCalculator/StackCalculator/IncorrectExpressionException.cs @@ -5,5 +5,5 @@ /// public class IncorrectExpressionException : Exception { - public IncorrectExpressionException(string? message) : base(message) { } + public IncorrectExpressionException() : base() { } } \ No newline at end of file diff --git a/Homework2/StackCalculator/StackCalculator/InvalidCharacterException.cs b/Homework2/StackCalculator/StackCalculator/InvalidCharacterException.cs index 1ad94ff..6500cdd 100644 --- a/Homework2/StackCalculator/StackCalculator/InvalidCharacterException.cs +++ b/Homework2/StackCalculator/StackCalculator/InvalidCharacterException.cs @@ -5,5 +5,5 @@ /// public class InvalidCharacterException : Exception { - public InvalidCharacterException(string? message) : base(message) { } + public InvalidCharacterException() : base() { } } \ No newline at end of file diff --git a/Homework2/StackCalculator/StackCalculator/StackException.cs b/Homework2/StackCalculator/StackCalculator/StackException.cs deleted file mode 100644 index 03ccccb..0000000 --- a/Homework2/StackCalculator/StackCalculator/StackException.cs +++ /dev/null @@ -1,9 +0,0 @@ -namespace Stack; - -/// -/// A class for creating custom exceptions -/// -public class StackException : Exception -{ - public StackException(string? message) : base(message) { } -} diff --git a/Homework2/StackCalculator/StackCalculator/StackIsEmptyException.cs b/Homework2/StackCalculator/StackCalculator/StackIsEmptyException.cs new file mode 100644 index 0000000..9264793 --- /dev/null +++ b/Homework2/StackCalculator/StackCalculator/StackIsEmptyException.cs @@ -0,0 +1,9 @@ +namespace Stack; + +/// +/// A class for creating custom exceptions +/// +public class StackIsEmptyException : Exception +{ + public StackIsEmptyException() : base() { } +} diff --git a/Homework2/StackCalculator/StackCalculator/StackOnArray.cs b/Homework2/StackCalculator/StackCalculator/StackOnArray.cs index 3a6f7fd..ba9a9fe 100644 --- a/Homework2/StackCalculator/StackCalculator/StackOnArray.cs +++ b/Homework2/StackCalculator/StackCalculator/StackOnArray.cs @@ -47,7 +47,7 @@ public T Pop() { if (numberOfElements == 0 || values == null) { - throw new StackException("Stack is empty"); + throw new StackIsEmptyException(); } T topOfSTack = values[numberOfElements - 1]; Array.Clear(values, numberOfElements - 1, 1); @@ -63,7 +63,7 @@ public T TopOfTheStack() { if (numberOfElements == 0 || values == null) { - throw new StackException("Stack is empty"); + throw new StackIsEmptyException(); } return values[numberOfElements - 1]; } diff --git a/Homework2/StackCalculator/StackCalculator/StackOnLists.cs b/Homework2/StackCalculator/StackCalculator/StackOnLists.cs index 4fa75c0..43ae82e 100644 --- a/Homework2/StackCalculator/StackCalculator/StackOnLists.cs +++ b/Homework2/StackCalculator/StackCalculator/StackOnLists.cs @@ -43,7 +43,7 @@ public void Push(T value) { if (head == null) { - throw new StackException("Stack is empty"); + throw new StackIsEmptyException(); } if (head != null) { @@ -69,7 +69,7 @@ public void Push(T value) { if (head == null) { - throw new StackException("Stack is empty"); + throw new StackIsEmptyException(); } return head == null ? default : head.Value; } diff --git a/Homework2/StackCalculator/TestStackCalculator/TestStack.cs b/Homework2/StackCalculator/TestStackCalculator/TestStack.cs index aa449a0..a6ffa2b 100644 --- a/Homework2/StackCalculator/TestStackCalculator/TestStack.cs +++ b/Homework2/StackCalculator/TestStackCalculator/TestStack.cs @@ -19,7 +19,7 @@ private static IEnumerable Stacks [TestCaseSource(nameof(Stacks))] public void ShouldThrowsStackExceptionWhenRemoveFromEmptyStack(IStack stack) { - var exception = Assert.Throws(() => stack?.Pop()); + var exception = Assert.Throws(() => stack?.Pop()); } [TestCaseSource(nameof(Stacks))] @@ -32,7 +32,7 @@ public void ShouldStackNotEmptyAfterPush(IStack stack) [TestCaseSource(nameof(Stacks))] public void ShouldThrowsStackExceptionWhenTopOfTheStackFromEmptyStack(IStack stack) { - var exception = Assert.Throws(() => stack?.TopOfTheStack()); + var exception = Assert.Throws(() => stack?.TopOfTheStack()); } [TestCaseSource(nameof(Stacks))] From 8f6905f692496a0d9a4900204789e06d16db5801 Mon Sep 17 00:00:00 2001 From: MinyazevR Date: Mon, 11 Apr 2022 22:46:18 +0300 Subject: [PATCH 06/10] Removing unnecessary code --- Homework2/StackCalculator/TestStackCalculator/TestStack.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Homework2/StackCalculator/TestStackCalculator/TestStack.cs b/Homework2/StackCalculator/TestStackCalculator/TestStack.cs index a6ffa2b..58544de 100644 --- a/Homework2/StackCalculator/TestStackCalculator/TestStack.cs +++ b/Homework2/StackCalculator/TestStackCalculator/TestStack.cs @@ -19,7 +19,7 @@ private static IEnumerable Stacks [TestCaseSource(nameof(Stacks))] public void ShouldThrowsStackExceptionWhenRemoveFromEmptyStack(IStack stack) { - var exception = Assert.Throws(() => stack?.Pop()); + Assert.Throws(() => stack?.Pop()); } [TestCaseSource(nameof(Stacks))] @@ -32,7 +32,7 @@ public void ShouldStackNotEmptyAfterPush(IStack stack) [TestCaseSource(nameof(Stacks))] public void ShouldThrowsStackExceptionWhenTopOfTheStackFromEmptyStack(IStack stack) { - var exception = Assert.Throws(() => stack?.TopOfTheStack()); + Assert.Throws(() => stack?.TopOfTheStack()); } [TestCaseSource(nameof(Stacks))] From 33eba1a0f92a329ab92b08c7231e23dfafc86982 Mon Sep 17 00:00:00 2001 From: MinyazevR Date: Thu, 21 Apr 2022 02:22:24 +0300 Subject: [PATCH 07/10] Changing the code by style guide --- .../StackCalculator/Calculator.cs | 17 ++++++++--- .../StackCalculator/StackOnArray.cs | 4 +++ .../StackCalculator/StackOnLists.cs | 2 ++ .../TestStackCalculator/TestStack.cs | 30 +++++++++---------- 4 files changed, 34 insertions(+), 19 deletions(-) diff --git a/Homework2/StackCalculator/StackCalculator/Calculator.cs b/Homework2/StackCalculator/StackCalculator/Calculator.cs index ab53048..8183b2a 100644 --- a/Homework2/StackCalculator/StackCalculator/Calculator.cs +++ b/Homework2/StackCalculator/StackCalculator/Calculator.cs @@ -19,18 +19,20 @@ public float CountTheExpressionInPostfixForm(string[] inputString, IStack { continue; } - int number = 0; - if (int.TryParse(inputString[i], out number)) + + if (int.TryParse(inputString[i], out int number)) { stack.Push(number); continue; } + if (stack.NumberOfElements() < 2) { throw new IncorrectExpressionException(); } - float secondNumber = 0; - float firstNumber = 0; + + float secondNumber; + float firstNumber; try { secondNumber = stack.Pop(); @@ -40,6 +42,7 @@ public float CountTheExpressionInPostfixForm(string[] inputString, IStack { throw; } + switch (inputString[i]) { case "+" : @@ -47,16 +50,19 @@ public float CountTheExpressionInPostfixForm(string[] inputString, IStack stack.Push(firstNumber + secondNumber); break; } + case "-" : { stack.Push(firstNumber - secondNumber); break; } + case "*" : { stack.Push(firstNumber * secondNumber); break; } + case "/" : { if (Math.Abs(secondNumber - 0) < 0.0000000000000000000000000001) @@ -66,16 +72,19 @@ public float CountTheExpressionInPostfixForm(string[] inputString, IStack stack.Push(firstNumber / secondNumber); break; } + default : { throw new InvalidCharacterException(); } } } + if (stack.NumberOfElements() != 1) { throw new IncorrectExpressionException(); } + return stack.Pop(); } } diff --git a/Homework2/StackCalculator/StackCalculator/StackOnArray.cs b/Homework2/StackCalculator/StackCalculator/StackOnArray.cs index ba9a9fe..a4676ee 100644 --- a/Homework2/StackCalculator/StackCalculator/StackOnArray.cs +++ b/Homework2/StackCalculator/StackCalculator/StackOnArray.cs @@ -31,11 +31,13 @@ public void Push(T value) { Array.Resize(ref values, values.Length + 20); } + numberOfElements++; if (values == null) { return; } + values[numberOfElements - 1] = value; } @@ -49,6 +51,7 @@ public T Pop() { throw new StackIsEmptyException(); } + T topOfSTack = values[numberOfElements - 1]; Array.Clear(values, numberOfElements - 1, 1); numberOfElements--; @@ -65,6 +68,7 @@ public T TopOfTheStack() { throw new StackIsEmptyException(); } + return values[numberOfElements - 1]; } diff --git a/Homework2/StackCalculator/StackCalculator/StackOnLists.cs b/Homework2/StackCalculator/StackCalculator/StackOnLists.cs index 43ae82e..07770ba 100644 --- a/Homework2/StackCalculator/StackCalculator/StackOnLists.cs +++ b/Homework2/StackCalculator/StackCalculator/StackOnLists.cs @@ -45,6 +45,7 @@ public void Push(T value) { throw new StackIsEmptyException(); } + if (head != null) { T? value = head.Value; @@ -83,6 +84,7 @@ public void PrintStack() { return; } + StackElement? copyHead = head; while (copyHead != null) { diff --git a/Homework2/StackCalculator/TestStackCalculator/TestStack.cs b/Homework2/StackCalculator/TestStackCalculator/TestStack.cs index 58544de..c3a2c6f 100644 --- a/Homework2/StackCalculator/TestStackCalculator/TestStack.cs +++ b/Homework2/StackCalculator/TestStackCalculator/TestStack.cs @@ -19,7 +19,7 @@ private static IEnumerable Stacks [TestCaseSource(nameof(Stacks))] public void ShouldThrowsStackExceptionWhenRemoveFromEmptyStack(IStack stack) { - Assert.Throws(() => stack?.Pop()); + Assert.Throws(() => stack.Pop()); } [TestCaseSource(nameof(Stacks))] @@ -32,45 +32,45 @@ public void ShouldStackNotEmptyAfterPush(IStack stack) [TestCaseSource(nameof(Stacks))] public void ShouldThrowsStackExceptionWhenTopOfTheStackFromEmptyStack(IStack stack) { - Assert.Throws(() => stack?.TopOfTheStack()); + Assert.Throws(() => stack.TopOfTheStack()); } [TestCaseSource(nameof(Stacks))] public void ShouldTopOfTheStackEqual1WhenPush1(IStack stack) { - stack?.Push(1); - Assert.AreEqual(1, stack?.TopOfTheStack()); + stack.Push(1); + Assert.AreEqual(1, stack.TopOfTheStack()); } [TestCaseSource(nameof(Stacks))] public void ShouldNumberOFElementsEqualZeroWhenEmptyStack(IStack stack) { - Assert.AreEqual(0, stack?.NumberOfElements()); + Assert.AreEqual(0, stack.NumberOfElements()); } [TestCaseSource(nameof(Stacks))] public void ShouldNumberOfElementsEqual1WhenPushInEmptyStack(IStack stack) { - stack?.Push(1); - Assert.AreEqual(1, stack?.NumberOfElements()); + stack.Push(1); + Assert.AreEqual(1, stack.NumberOfElements()); } [TestCaseSource(nameof(Stacks))] public void ShouldNumberOfElementsNotChangesWhenRemoveAfterPush(IStack stack) { - stack?.Push(1); - Assert.AreEqual(1, stack?.NumberOfElements()); - stack?.Pop(); - Assert.AreEqual(0, stack?.NumberOfElements()); + stack.Push(1); + Assert.AreEqual(1, stack.NumberOfElements()); + stack.Pop(); + Assert.AreEqual(0, stack.NumberOfElements()); } [TestCaseSource(nameof(Stacks))] public void ShouldTopOfTheStackNotChangesWhenPrintStack(IStack stack) { - stack?.Push(1); - stack?.Push(2); - stack?.PrintStack(); - Assert.AreEqual(2, stack?.TopOfTheStack()); + stack.Push(1); + stack.Push(2); + stack.PrintStack(); + Assert.AreEqual(2, stack.TopOfTheStack()); } } From 0dfd251c5fa9e0aa797f5750b29bab8b8dc3275c Mon Sep 17 00:00:00 2001 From: Roman Date: Thu, 2 Jun 2022 00:44:06 +0300 Subject: [PATCH 08/10] add yml --- .github/workflows/StackCalculator.yml | 29 +++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 .github/workflows/StackCalculator.yml diff --git a/.github/workflows/StackCalculator.yml b/.github/workflows/StackCalculator.yml new file mode 100644 index 0000000..aea5886 --- /dev/null +++ b/.github/workflows/StackCalculator.yml @@ -0,0 +1,29 @@ +name: Build + +on: [push] + +jobs: + build-Windows: + + runs-on: windows-latest + + @@ -20,4 +20,19 @@ jobs: + - name: Test + run: $slnList = Get-ChildItem $foo.FullName -Recurse -Filter '*.sln'; foreach ($file in $slnList) {dotnet test $file.FullName} + + build-Ubuntu: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + - name: Build + uses: actions/setup-dotnet@v1 + with: + dotnet-version: '6.x' + - name: Restore + run: for f in $(find . -name "*.sln"); do dotnet restore $f; done + - name: Build + run: for f in $(find . -name "*.sln"); do dotnet build $f; done + - name: Test + run: for f in $(find . -name "*.sln"); do dotnet test $f; done \ No newline at end of file From f909b96adb90573d473e6026af9c9c2283d786ac Mon Sep 17 00:00:00 2001 From: Roman Date: Thu, 2 Jun 2022 00:45:54 +0300 Subject: [PATCH 09/10] fixed yml --- .github/workflows/StackCalculator.yml | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/.github/workflows/StackCalculator.yml b/.github/workflows/StackCalculator.yml index aea5886..94ac0b1 100644 --- a/.github/workflows/StackCalculator.yml +++ b/.github/workflows/StackCalculator.yml @@ -7,7 +7,16 @@ jobs: runs-on: windows-latest - @@ -20,4 +20,19 @@ jobs: + steps: + - uses: actions/checkout@v2 + - name: Build + uses: actions/setup-dotnet@v1 + with: + dotnet-version: '6.x' + - name: Restore + run: $slnList = Get-ChildItem $foo.FullName -Recurse -Filter '*.sln'; foreach ($file in $slnList) {nuget restore $file.FullName} + - name: Build + run: $slnList = Get-ChildItem $foo.FullName -Recurse -Filter '*.sln'; foreach ($file in $slnList) {dotnet build $file.FullName} - name: Test run: $slnList = Get-ChildItem $foo.FullName -Recurse -Filter '*.sln'; foreach ($file in $slnList) {dotnet test $file.FullName} From b8ce61cf36aa9243fbeed2d96c0e415cd86e57fd Mon Sep 17 00:00:00 2001 From: Roman Date: Thu, 2 Jun 2022 01:14:23 +0300 Subject: [PATCH 10/10] rename yml --- .github/workflows/{StackCalculator.yml => dotnet.yml} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename .github/workflows/{StackCalculator.yml => dotnet.yml} (100%) diff --git a/.github/workflows/StackCalculator.yml b/.github/workflows/dotnet.yml similarity index 100% rename from .github/workflows/StackCalculator.yml rename to .github/workflows/dotnet.yml