Исправление. Кондрашова Виктория. 3823Б1ПР1. ST-4. b7.

.gitignore

@@ -0,0 +1,15 @@
+# Сборка .NET
+bin/
+obj/
+
+# IDEs
+.idea/
+.vscode/
+*.user
+*.suo
+*.userosscache
+*.sln.docstates
+
+# Системные файлы
+.DS_Store
+Thumbs.db

BugPro/BugPro.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Stateless" Version="5.13.0" />
+  </ItemGroup>
+
+</Project>

BugPro/Program.cs

@@ -0,0 +1,88 @@
+using System;
+using Stateless;
+
+namespace BugPro
+{
+    public enum State
+    {
+        NewDefect,
+        Triage,
+        Fixing,
+        Closed
+    }
+
+    public enum Trigger
+    {
+        Assign,
+        StartFix,
+        NotADefect,
+        WontFix,
+        Duplicate,
+        NoTimeNow,
+        NeedsSeparateSolution,
+        OtherProductProblem,
+        NeedMoreInfo,
+        CannotReproduceAndOK,
+        CannotReproduceAndNotOK,
+        FixAccepted,
+        FixRejected,
+        Reopen
+    }
+
+    public class Bug
+    {
+        private readonly StateMachine<State, Trigger> _machine;
+
+        public State CurrentState => _machine.State;
+
+        public Bug()
+        {
+            _machine = new StateMachine<State, Trigger>(State.NewDefect);
+
+            _machine.Configure(State.NewDefect)
+                .Permit(Trigger.Assign, State.Triage);
+
+            _machine.Configure(State.Triage)
+                .Permit(Trigger.StartFix, State.Fixing)
+                .Permit(Trigger.NotADefect, State.Closed)
+                .Permit(Trigger.WontFix, State.Closed)
+                .Permit(Trigger.Duplicate, State.Closed);
+
+            _machine.Configure(State.Fixing)
+                .Permit(Trigger.NoTimeNow, State.Triage)
+                .Permit(Trigger.NeedsSeparateSolution, State.Triage)
+                .Permit(Trigger.OtherProductProblem, State.Triage)
+                .Permit(Trigger.NeedMoreInfo, State.Triage)
+                .Permit(Trigger.CannotReproduceAndOK, State.Closed)
+                .Permit(Trigger.CannotReproduceAndNotOK, State.Triage)
+                .Permit(Trigger.FixAccepted, State.Closed)
+                .Permit(Trigger.FixRejected, State.Triage);
+
+            _machine.Configure(State.Closed)
+                .Permit(Trigger.Reopen, State.Triage);
+        }
+
+        public void Fire(Trigger trigger)
+        {
+            _machine.Fire(trigger);
+        }
+    }
+
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            var bug = new Bug();
+            Console.WriteLine($"Начальное состояние: {bug.CurrentState}");
+
+            bug.Fire(Trigger.Assign);
+            Console.WriteLine($"После назначения: {bug.CurrentState}");
+
+            bug.Fire(Trigger.StartFix);
+            Console.WriteLine($"Взято в работу: {bug.CurrentState}");
+
+            bug.Fire(Trigger.FixAccepted);
+            Console.WriteLine($"Проблема решена (ДА): {bug.CurrentState}");
+        }
+    }
+}

BugTests/BugTests.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.1" />
+    <PackageReference Include="MSTest.TestAdapter" Version="2.2.10" />
+    <PackageReference Include="MSTest.TestFramework" Version="2.2.10" />
+    <PackageReference Include="coverlet.collector" Version="3.2.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\BugPro\BugPro.csproj" />
+  </ItemGroup>
+
+</Project>

BugTests/GlobalUsings.cs

@@ -0,0 +1 @@
+global using Microsoft.VisualStudio.TestTools.UnitTesting;

BugTests/UnitTest1.cs

@@ -0,0 +1,193 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using BugPro;
+using Stateless;
+namespace BugTests
+{
+    [TestClass]
+    public class UnitTest1
+    {
+        [TestMethod]
+        public void InitialState_IsNewDefect()
+        {
+            var bug = new Bug();
+            Assert.AreEqual(State.NewDefect, bug.CurrentState);
+        }
+        [TestMethod]
+        public void Assign_FromNewDefect_GoesToTriage()
+        {
+            var bug = new Bug();
+            bug.Fire(Trigger.Assign);
+            Assert.AreEqual(State.Triage, bug.CurrentState);
+        }
+        [TestMethod]
+        public void StartFix_FromTriage_GoesToFixing()
+        {
+            var bug = new Bug();
+            bug.Fire(Trigger.Assign);
+            bug.Fire(Trigger.StartFix);
+            Assert.AreEqual(State.Fixing, bug.CurrentState);
+        }
+        [TestMethod]
+        public void NotADefect_FromTriage_GoesToClosed()
+        {
+            var bug = new Bug();
+            bug.Fire(Trigger.Assign);
+            bug.Fire(Trigger.NotADefect);
+            Assert.AreEqual(State.Closed, bug.CurrentState);
+        }
+        [TestMethod]
+        public void WontFix_FromTriage_GoesToClosed()
+        {
+            var bug = new Bug();
+            bug.Fire(Trigger.Assign);
+            bug.Fire(Trigger.WontFix);
+            Assert.AreEqual(State.Closed, bug.CurrentState);
+        }
+        [TestMethod]
+        public void Duplicate_FromTriage_GoesToClosed()
+        {
+            var bug = new Bug();
+            bug.Fire(Trigger.Assign);
+            bug.Fire(Trigger.Duplicate);
+            Assert.AreEqual(State.Closed, bug.CurrentState);
+        }
+        [TestMethod]
+        public void NoTimeNow_FromFixing_GoesToTriage()
+        {
+            var bug = new Bug();
+            bug.Fire(Trigger.Assign);
+            bug.Fire(Trigger.StartFix);
+            bug.Fire(Trigger.NoTimeNow);
+            Assert.AreEqual(State.Triage, bug.CurrentState);
+        }
+        [TestMethod]
+        public void NeedsSeparateSolution_FromFixing_GoesToTriage()
+        {
+            var bug = new Bug();
+            bug.Fire(Trigger.Assign);
+            bug.Fire(Trigger.StartFix);
+            bug.Fire(Trigger.NeedsSeparateSolution);
+            Assert.AreEqual(State.Triage, bug.CurrentState);
+        }
+        [TestMethod]
+        public void OtherProductProblem_FromFixing_GoesToTriage()
+        {
+            var bug = new Bug();
+            bug.Fire(Trigger.Assign);
+            bug.Fire(Trigger.StartFix);
+            bug.Fire(Trigger.OtherProductProblem);
+            Assert.AreEqual(State.Triage, bug.CurrentState);
+        }
+        [TestMethod]
+        public void NeedMoreInfo_FromFixing_GoesToTriage()
+        {
+            var bug = new Bug();
+            bug.Fire(Trigger.Assign);
+            bug.Fire(Trigger.StartFix);
+            bug.Fire(Trigger.NeedMoreInfo);
+            Assert.AreEqual(State.Triage, bug.CurrentState);
+        }
+        [TestMethod]
+        public void CannotReproduceAndOK_FromFixing_GoesToClosed()
+        {
+            var bug = new Bug();
+            bug.Fire(Trigger.Assign);
+            bug.Fire(Trigger.StartFix);
+            bug.Fire(Trigger.CannotReproduceAndOK);
+            Assert.AreEqual(State.Closed, bug.CurrentState);
+        }
+        [TestMethod]
+        public void CannotReproduceAndNotOK_FromFixing_GoesToTriage()
+        {
+            var bug = new Bug();
+            bug.Fire(Trigger.Assign);
+            bug.Fire(Trigger.StartFix);
+            bug.Fire(Trigger.CannotReproduceAndNotOK);
+            Assert.AreEqual(State.Triage, bug.CurrentState);
+        }
+        [TestMethod]
+        public void FixAccepted_FromFixing_GoesToClosed()
+        {
+            var bug = new Bug();
+            bug.Fire(Trigger.Assign);
+            bug.Fire(Trigger.StartFix);
+            bug.Fire(Trigger.FixAccepted);
+            Assert.AreEqual(State.Closed, bug.CurrentState);
+        }
+        [TestMethod]
+        public void FixRejected_FromFixing_GoesToTriage()
+        {
+            var bug = new Bug();
+            bug.Fire(Trigger.Assign);
+            bug.Fire(Trigger.StartFix);
+            bug.Fire(Trigger.FixRejected);
+            Assert.AreEqual(State.Triage, bug.CurrentState);
+        }
+        [TestMethod]
+        public void Reopen_FromClosed_GoesToTriage()
+        {
+            var bug = new Bug();
+            bug.Fire(Trigger.Assign);
+            bug.Fire(Trigger.NotADefect);
+            bug.Fire(Trigger.Reopen);
+            Assert.AreEqual(State.Triage, bug.CurrentState);
+        }
+        [TestMethod]
+        [ExpectedException(typeof(InvalidOperationException))]
+        public void Invalid_StartFix_FromNewDefect_ThrowsException()
+        {
+            var bug = new Bug();
+            bug.Fire(Trigger.StartFix);
+        }
+        [TestMethod]
+        [ExpectedException(typeof(InvalidOperationException))]
+        public void Invalid_FixAccepted_FromNewDefect_ThrowsException()
+        {
+            var bug = new Bug();
+            bug.Fire(Trigger.FixAccepted);
+        }
+        [TestMethod]
+        [ExpectedException(typeof(InvalidOperationException))]
+        public void Invalid_Assign_FromTriage_ThrowsException()
+        {
+            var bug = new Bug();
+            bug.Fire(Trigger.Assign);
+            bug.Fire(Trigger.Assign);
+        }
+        [TestMethod]
+        [ExpectedException(typeof(InvalidOperationException))]
+        public void Invalid_StartFix_FromFixing_ThrowsException()
+        {
+            var bug = new Bug();
+            bug.Fire(Trigger.Assign);
+            bug.Fire(Trigger.StartFix);
+            bug.Fire(Trigger.StartFix);
+        }
+        [TestMethod]
+        [ExpectedException(typeof(InvalidOperationException))]
+        public void Invalid_FixAccepted_FromClosed_ThrowsException()
+        {
+            var bug = new Bug();
+            bug.Fire(Trigger.Assign);
+            bug.Fire(Trigger.NotADefect);
+            bug.Fire(Trigger.FixAccepted);
+        }
+        [TestMethod]
+        [ExpectedException(typeof(InvalidOperationException))]
+        public void Invalid_StartFix_FromClosed_ThrowsException()
+        {
+            var bug = new Bug();
+            bug.Fire(Trigger.Assign);
+            bug.Fire(Trigger.NotADefect);
+            bug.Fire(Trigger.StartFix);
+        }
+        [TestMethod]
+        [ExpectedException(typeof(InvalidOperationException))]
+        public void Invalid_Reopen_FromNewDefect_ThrowsException()
+        {
+            var bug = new Bug();
+            bug.Fire(Trigger.Reopen);
+        }
+    }
+}

ST-4.sln

@@ -3,6 +3,10 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 17
 VisualStudioVersion = 17.0.31903.59
 MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BugPro", "BugPro\BugPro.csproj", "{69E7D115-E4A0-4D84-8EA8-EECEB5B1815D}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BugTests", "BugTests\BugTests.csproj", "{C898FD7F-75FA-4A27-A73E-18ABACB1A198}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -11,4 +15,14 @@ Global
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{69E7D115-E4A0-4D84-8EA8-EECEB5B1815D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{69E7D115-E4A0-4D84-8EA8-EECEB5B1815D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{69E7D115-E4A0-4D84-8EA8-EECEB5B1815D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{69E7D115-E4A0-4D84-8EA8-EECEB5B1815D}.Release|Any CPU.Build.0 = Release|Any CPU
+		{C898FD7F-75FA-4A27-A73E-18ABACB1A198}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{C898FD7F-75FA-4A27-A73E-18ABACB1A198}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{C898FD7F-75FA-4A27-A73E-18ABACB1A198}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{C898FD7F-75FA-4A27-A73E-18ABACB1A198}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
 EndGlobal