Merge pull request #1 from simongh/add-interfaces

Converted to .Net Standard
alphamax · Nov 8, 2016 · 0e753a1 · 0e753a1
2 parents 1859604 + 29b1abd
commit 0e753a1
Show file tree

Hide file tree

Showing 27 changed files with 1,466 additions and 1,420 deletions.
diff --git a/.gitignore b/.gitignore
@@ -2,3 +2,5 @@ bin
 obj
 *.suo
 *.vspscc
+/Sources/.vs
+/Sources/TinyWorkflow/project.lock.json
diff --git a/Sources/TinyWorkflow.Tests/AsynchStepTest.cs b/Sources/TinyWorkflow.Tests/AsynchStepTest.cs
@@ -1,74 +1,75 @@
 using System;
+using System.Threading;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using TinyWorkflow.Tests.States;
-using System.Threading;
 
 namespace TinyWorkflow.Tests
 {
-    [TestClass]
-    public class AsynchStepTest
-    {
-        Workflow<SimpleState> temporaryWorkflow;
-        [TestMethod]
-        public void RunOneAsynchStep()
-        {
-            temporaryWorkflow = new Workflow<SimpleState>()
-                .DoAsynch(EasyAction)
-                .Block()
-                .Do(EasyAsynchronousTestValidation);
-            temporaryWorkflow.Start(new SimpleState());
-            Thread.Sleep(3000);
-        }
+	[TestClass]
+	public class AsynchStepTest
+	{
+		private IWorkflow<SimpleState> temporaryWorkflow;
+
+		[TestMethod]
+		public void RunOneAsynchStep()
+		{
+			temporaryWorkflow = new Workflow<SimpleState>()
+				.DoAsynch(EasyAction)
+				.Block()
+				.Do(EasyAsynchronousTestValidation);
+			temporaryWorkflow.Start(new SimpleState());
+			Thread.Sleep(3000);
+		}
 
-        [TestMethod]
-        public void RunMultipleAsynchStep()
-        {
-            temporaryWorkflow = new Workflow<SimpleState>()
-                .DoAsynch(EasyActionAsynch1,EasyActionAsynch2,EasyActionAsynch3)
-                .Block(3)
-                .Do(AsynchronousTestValidation);
-            temporaryWorkflow.Start(new SimpleState());
-            Thread.Sleep(3000);
-        }
+		[TestMethod]
+		public void RunMultipleAsynchStep()
+		{
+			temporaryWorkflow = new Workflow<SimpleState>()
+				.DoAsynch(EasyActionAsynch1, EasyActionAsynch2, EasyActionAsynch3)
+				.Block(3)
+				.Do(AsynchronousTestValidation);
+			temporaryWorkflow.Start(new SimpleState());
+			Thread.Sleep(3000);
+		}
 
-        public void EasyAsynchronousTestValidation(SimpleState state)
-        {
-            Assert.AreEqual(1, state.StateFullVariable);
-        }
+		public void EasyAsynchronousTestValidation(SimpleState state)
+		{
+			Assert.AreEqual(1, state.StateFullVariable);
+		}
 
-        public void AsynchronousTestValidation(SimpleState state)
-        {
-            Assert.AreEqual(10, state.StateFullVariableAsynch1);
-            Assert.AreEqual(20, state.StateFullVariableAsynch2);
-            Assert.AreEqual(30, state.StateFullVariableAsynch3);
-        }
+		public void AsynchronousTestValidation(SimpleState state)
+		{
+			Assert.AreEqual(10, state.StateFullVariableAsynch1);
+			Assert.AreEqual(20, state.StateFullVariableAsynch2);
+			Assert.AreEqual(30, state.StateFullVariableAsynch3);
+		}
 
-        public void EasyAction(SimpleState state)
-        {
-            Thread.Sleep(1000);
-            state.StateFullVariable = 1;
-            temporaryWorkflow.Unblock();
-        }
+		public void EasyAction(SimpleState state)
+		{
+			Thread.Sleep(1000);
+			state.StateFullVariable = 1;
+			temporaryWorkflow.Unblock();
+		}
 
-        public void EasyActionAsynch1(SimpleState state)
-        {
-            Thread.Sleep(1200);
-            state.StateFullVariableAsynch1 = 10;
-            temporaryWorkflow.Unblock();
-        }
+		public void EasyActionAsynch1(SimpleState state)
+		{
+			Thread.Sleep(1200);
+			state.StateFullVariableAsynch1 = 10;
+			temporaryWorkflow.Unblock();
+		}
 
-        public void EasyActionAsynch2(SimpleState state)
-        {
-            Thread.Sleep(700);
-            state.StateFullVariableAsynch2 = 20;
-            temporaryWorkflow.Unblock();
-        }
+		public void EasyActionAsynch2(SimpleState state)
+		{
+			Thread.Sleep(700);
+			state.StateFullVariableAsynch2 = 20;
+			temporaryWorkflow.Unblock();
+		}
 
-        public void EasyActionAsynch3(SimpleState state)
-        {
-            Thread.Sleep(1000);
-            state.StateFullVariableAsynch3 = 30;
-            temporaryWorkflow.Unblock();
-        }
-    }
-}
+		public void EasyActionAsynch3(SimpleState state)
+		{
+			Thread.Sleep(1000);
+			state.StateFullVariableAsynch3 = 30;
+			temporaryWorkflow.Unblock();
+		}
+	}
+}
diff --git a/Sources/TinyWorkflow.Tests/BlockIfStepTest.cs b/Sources/TinyWorkflow.Tests/BlockIfStepTest.cs
@@ -4,58 +4,58 @@
 
 namespace TinyWorkflow.Tests
 {
-    [TestClass]
-    public class BlockIfStepTest
-    {
-        [TestMethod]
-        public void RunIfTrueAndBlock()
-        {
-            Workflow<SimpleState> workflow = new Workflow<SimpleState>()
-                .If(TestToTrue, ActionIfTrue, ActionIfFalse)
-                .Block()
-                .Do(ActionAfter);
-            workflow.Start(new SimpleState());
-            Assert.AreEqual(2, workflow.Workload.StateFullVariable);
-            workflow.Unblock();
-            Assert.AreEqual(3, workflow.Workload.StateFullVariable);
-        }
+	[TestClass]
+	public class BlockIfStepTest
+	{
+		[TestMethod]
+		public void RunIfTrueAndBlock()
+		{
+			var workflow = new Workflow<SimpleState>()
+				.If(TestToTrue, ActionIfTrue, ActionIfFalse)
+				.Block()
+				.Do(ActionAfter);
+			workflow.Start(new SimpleState());
+			Assert.AreEqual(2, workflow.Workload.StateFullVariable);
+			workflow.Unblock();
+			Assert.AreEqual(3, workflow.Workload.StateFullVariable);
+		}
 
-        [TestMethod]
-        public void RunIfFalseAndBlock()
-        {
-            Workflow<SimpleState> workflow = new Workflow<SimpleState>()
-                .If(TestToFalse, ActionIfTrue, ActionIfFalse)
-                .Block()
-                .Do(ActionAfter);
-            workflow.Start(new SimpleState());
-            Assert.AreEqual(3, workflow.Workload.StateFullVariable);
-            workflow.Unblock();
-            Assert.AreEqual(4, workflow.Workload.StateFullVariable);
-        }
+		[TestMethod]
+		public void RunIfFalseAndBlock()
+		{
+			var workflow = new Workflow<SimpleState>()
+				.If(TestToFalse, ActionIfTrue, ActionIfFalse)
+				.Block()
+				.Do(ActionAfter);
+			workflow.Start(new SimpleState());
+			Assert.AreEqual(3, workflow.Workload.StateFullVariable);
+			workflow.Unblock();
+			Assert.AreEqual(4, workflow.Workload.StateFullVariable);
+		}
 
-        public bool TestToTrue(SimpleState state)
-        {
-            return state.StateFullVariable == 0;
-        }
+		public bool TestToTrue(SimpleState state)
+		{
+			return state.StateFullVariable == 0;
+		}
 
-        public bool TestToFalse(SimpleState state)
-        {
-            return state.StateFullVariable != 0;
-        }
+		public bool TestToFalse(SimpleState state)
+		{
+			return state.StateFullVariable != 0;
+		}
 
-        public void ActionIfTrue(SimpleState state)
-        {
-            state.StateFullVariable = 2;
-        }
+		public void ActionIfTrue(SimpleState state)
+		{
+			state.StateFullVariable = 2;
+		}
 
-        public void ActionIfFalse(SimpleState state)
-        {
-            state.StateFullVariable = 3;
-        }
+		public void ActionIfFalse(SimpleState state)
+		{
+			state.StateFullVariable = 3;
+		}
 
-        public void ActionAfter(SimpleState state)
-        {
-            state.StateFullVariable++;
-        }
-    }
-}
+		public void ActionAfter(SimpleState state)
+		{
+			state.StateFullVariable++;
+		}
+	}
+}
diff --git a/Sources/TinyWorkflow.Tests/BlockSimpleStepTest.cs b/Sources/TinyWorkflow.Tests/BlockSimpleStepTest.cs
@@ -1,38 +1,38 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 using TinyWorkflow.Tests.States;
 
 namespace TinyWorkflow.Tests
 {
-    [TestClass]
-    public class BlockSimpleStepTest
-    {
-        [TestMethod]
-        public void SimpleStepBlock()
-        {
-            Workflow<SimpleState> workflow = new Workflow<SimpleState>()
-                .Do(ActionBeforeBlock)
-                .Block()
-                .Do(ActionAfterBlock);
+	[TestClass]
+	public class BlockSimpleStepTest
+	{
+		[TestMethod]
+		public void SimpleStepBlock()
+		{
+			var workflow = new Workflow<SimpleState>()
+				.Do(ActionBeforeBlock)
+				.Block()
+				.Do(ActionAfterBlock);
 
-            workflow.Start(new SimpleState());
-            Assert.AreEqual(5, workflow.Workload.StateFullVariable);
-            workflow.Unblock();
-            Assert.AreEqual(10, workflow.Workload.StateFullVariable);
-        }
+			workflow.Start(new SimpleState());
+			Assert.AreEqual(5, workflow.Workload.StateFullVariable);
+			workflow.Unblock();
+			Assert.AreEqual(10, workflow.Workload.StateFullVariable);
+		}
 
-        public void ActionBeforeBlock(SimpleState state)
-        {
-            state.StateFullVariable = 5;
-        }
+		public void ActionBeforeBlock(SimpleState state)
+		{
+			state.StateFullVariable = 5;
+		}
 
-        public void ActionAfterBlock(SimpleState state)
-        {
-            state.StateFullVariable = 10;
-        }
-    }
-}
+		public void ActionAfterBlock(SimpleState state)
+		{
+			state.StateFullVariable = 10;
+		}
+	}
+}