Testing

src/ControlComponents.Core/ConfigOperationMode.cs

@@ -121,11 +121,14 @@ namespace ControlComponents.Core
 
         protected override async Task Aborting(CancellationToken token)
         {
-            if(!token.IsCancellationRequested && _externalCC.OpModeName != "NONE" && _externalCC.EXST != ExecutionState.ABORTING)
+            if(_externalCC.OpModeName != "NONE")
             {
-                _externalCC.Abort(base.execution.ComponentName);
+                if(!token.IsCancellationRequested && _externalCC.EXST != ExecutionState.ABORTING)
+                {
+                    _externalCC.Abort(base.execution.ComponentName);
+                }
+                await MirrorState(token);
             }
-            await MirrorState(token);
             await base.Aborting(token);
         }
 

src/ControlComponents.Core/IControlComponentExtensions.cs

@@ -183,6 +183,27 @@ namespace ControlComponents.Core
             }
         }
 
+        public static async Task UnholdAndWaitExecute(this IControlComponent cc, string occupier)
+        {
+            if (cc.EXST == ExecutionState.HELD || cc.EXST == ExecutionState.UNHOLDING)
+            {
+                StateWaiter waiter = new StateWaiter();
+                cc.ExecutionStateChanged += waiter.EventHandler;
+
+                if (cc.EXST == ExecutionState.HELD)
+                {
+                    cc.Unhold(occupier);
+                }
+                await waiter.Execute();
+
+                cc.ExecutionStateChanged -= waiter.EventHandler;
+            }
+            else
+            {
+                logger.Warn($"{cc.ComponentName} is in state {cc.EXST}, but must be in EXECUTING OR HOLDING");
+            }
+        }
+
         public static async Task AbortAndWaitForAborted(this IControlComponent cc, string occupier)
         {
             if (cc.EXST != ExecutionState.ABORTED)

src/ControlComponents.Core/OperationModeBase.cs

@@ -113,6 +113,7 @@ namespace ControlComponents.Core
             }
             catch (System.Exception e)
             {
+                // TODO go to ABORTING?
                 logger.Error(e);
                 throw e;
             }
@@ -141,6 +142,7 @@ namespace ControlComponents.Core
             }
             catch (System.Exception e)
             {
+                // TODO go to ABORTING?
                 logger.Error(e, $"Outputs = {string.Join(" ", this.outputs.Keys)}");
                 throw e;
             }

src/ControlComponents.Core/OperationModeWaitOutputs.cs

@@ -26,6 +26,7 @@ namespace ControlComponents.Core
         protected override async Task Stopping(CancellationToken token)
         {
             await WaitForOutputs((IOrderOutput output) => output.StopAndWaitForStopped(this.execution.ComponentName));
+            // TODO is it right to Free here?
             foreach (var output in outputs.Values.Where(o => o.IsSet && o.IsUsableBy(execution.ComponentName)))
             {
                 output.Free(this.execution.ComponentName);
@@ -45,6 +46,7 @@ namespace ControlComponents.Core
         protected override async Task Clearing(CancellationToken token)
         {
             await WaitForOutputs((IOrderOutput output) => output.StopAndWaitForStopped(this.execution.ComponentName));
+            // TODO is it right to Free here?
             foreach (var output in outputs.Values.Where(o => o.IsSet && o.IsUsableBy(execution.ComponentName)))
             {
                 output.Free(this.execution.ComponentName);

tests/ControlComponents.Core.Tests/ConfigOperationModeTests.cs

+using System.Threading.Tasks;
+using AutoFixture.NUnit3;
+using FluentAssertions;
+using Moq;
+using NUnit.Framework;
+
+namespace ControlComponents.Core.Tests
+{
+    public class ConfigOperationModeTests
+    {
+        Mock<IControlComponentProvider> provider;
+
+        [SetUp]
+        public void Setup()
+        {
+            provider = new Mock<IControlComponentProvider>();
+        }
+
+        [Test, AutoData]
+        public async Task _df(ControlComponent cc, ControlComponent externalCC)
+        {
+            var sut = new ConfigOperationMode("CONFIG", externalCC);
+            cc.AddOperationMode(sut);
+            externalCC.AddOrderOutput(new OrderOutput("ROLE", externalCC.ComponentName, provider.Object));
+
+            Task running = cc.SelectOperationMode("CONFIG");
+            await cc.WaitForAborted();
+            cc.EXST.Should().Be(ExecutionState.ABORTED);
+        }
+    }
+}
\ No newline at end of file

tests/ControlComponents.Core.Tests/ControlComponentNoSelectedOpModeTests.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Threading.Tasks;
+using FluentAssertions;
 using Moq;
 using NUnit.Framework;
 
@@ -99,16 +100,9 @@ namespace ControlComponents.Core.Tests
             Assert.AreEqual(new Collection<string>(){OpModeOne, OpModeTwo}, cc.OpModes);
         }
 
-        // [Test]
-        // public void Given_OrderOuputs_When_ListRoles_Then_ReturnRoles()
-        // {
-        //     Assert.AreEqual(new List<string>(){"OrderOuputOne", "OrderOutput2"}, cc.Roles);
-        // }
-
         [Test]
         public async Task Given_Stopped_When_SelectOpMode_Then_NewOpMode()
         {
-            // var newOpMode = new OperationMode("NEWOPMODE");
             Task runningOpMode = cc.SelectOperationMode(OpModeOne);
             Assert.AreEqual(OpModeOne, cc.OpModeName);
 
@@ -117,6 +111,25 @@ namespace ControlComponents.Core.Tests
             Assert.AreEqual("NONE", cc.OpModeName);
         }
 
+        [Test]
+        [Ignore("Cannot be tested, because this state is not reachable")]
+        public async Task Given_Idle_When_SelectOpMode_Then_Throw()
+        {
+            Task runningOpMode = cc.SelectOperationMode(OpModeOne);
+            await cc.ResetAndWaitForIdle(SENDER);
+
+            await Task.WhenAll(
+                cc.SelectOperationMode(OpModeOne),
+                cc.SelectOperationMode(OpModeTwo)
+            );
+            // cc.Invoking(async c => await c.SelectOperationMode(OpModeTwo)).Should().Throw<InvalidOperationException>();
+
+            await cc.StopAndWaitForStopped(SENDER);
+            await cc.DeselectOperationMode();
+            await runningOpMode;
+            Assert.AreEqual("NONE", cc.OpModeName);
+        }
+
         [Test]
         public void Given_NoOperationModeSelected_When_Deselect_Then_DoNotThrow()
         {

tests/ControlComponents.Core.Tests/ControlComponentSelectedOpModeTests.cs

@@ -21,7 +21,7 @@ namespace ControlComponents.Core.Tests
         public void Setup()
         {
             Mock<IControlComponentProvider> provider = new Mock<IControlComponentProvider>();
-            var OpModes = new Collection<IOperationMode>(){ new OperationMode(OpModeOne), new OperationMode(OpModeTwo) };
+            var OpModes = new Collection<IOperationMode>(){ new OperationModeAsync(OpModeOne), new OperationModeAsync(OpModeTwo) };
             var orderOutputs = new Collection<IOrderOutput>() 
             { 
                 new OrderOutput("First", CC, provider.Object, new ControlComponent("CC1", OpModes, new Collection<IOrderOutput>(), new Collection<string>())),
@@ -63,6 +63,42 @@ namespace ControlComponents.Core.Tests
             Assert.AreEqual(ExecutionState.COMPLETED, cc.EXST);
         }
 
+        [Test]
+        public async Task Given_Stopped_When_NormalHoldRun_Then_Completed()
+        {
+            await cc.ResetAndWaitForIdle(SENDER);
+            Assert.AreEqual(ExecutionState.IDLE, cc.EXST);
+
+            await cc.StartAndWaitForExecute(SENDER);
+
+            await cc.HoldAndWaitForHeld(SENDER);
+            Assert.AreEqual(ExecutionState.HELD, cc.EXST);
+
+            await cc.UnholdAndWaitExecute(SENDER);
+            Assert.AreEqual(ExecutionState.EXECUTE, cc.EXST);
+
+            await cc.WaitForCompleted();
+            Assert.AreEqual(ExecutionState.COMPLETED, cc.EXST);
+        }
+
+        [Test]
+        public async Task Given_Stopped_When_NormalSuspendRun_Then_Completed()
+        {
+            await cc.ResetAndWaitForIdle(SENDER);
+            Assert.AreEqual(ExecutionState.IDLE, cc.EXST);
+
+            await cc.StartAndWaitForExecute(SENDER);
+
+            await cc.SuspendAndWaitForSuspended(SENDER);
+            Assert.AreEqual(ExecutionState.SUSPENDED, cc.EXST);
+
+            await cc.UnsuspendAndWaitForExecute(SENDER);
+            Assert.AreEqual(ExecutionState.EXECUTE, cc.EXST);
+
+            await cc.WaitForCompleted();
+            Assert.AreEqual(ExecutionState.COMPLETED, cc.EXST);
+        }
+
         [Test]
         public async Task Given_Idle_When_Deselect_Then_Throw()
         {

tests/ControlComponents.Core.Tests/FrameControlComponentTests.cs

@@ -231,6 +231,14 @@ namespace ControlComponents.Core.Tests
             sut.EXST.Should().Be(ExecutionState.EXECUTE);
             externalCC.EXST.Should().Be(ExecutionState.EXECUTE);
 
+            await sut.SuspendAndWaitForSuspended(SENDER);
+            sut.EXST.Should().Be(ExecutionState.SUSPENDED);
+            externalCC.EXST.Should().Be(ExecutionState.SUSPENDED);
+
+            await sut.UnsuspendAndWaitForExecute(SENDER);
+            sut.EXST.Should().Be(ExecutionState.EXECUTE);
+            externalCC.EXST.Should().Be(ExecutionState.EXECUTE);
+
             await sut.WaitForCompleted();
             sut.EXST.Should().Be(ExecutionState.COMPLETED);
             externalCC.EXST.Should().Be(ExecutionState.COMPLETED);

tests/ControlComponents.Core.Tests/IControlComponentExtensionsTests.cs

@@ -68,36 +68,50 @@ namespace ControlComponents.Core.Tests
         }
 
         [Test]
-        public async Task Given_Idle_When_Start_Then_Execute()
+        public async Task Given_Aborting_When_StopAndWaitForStopped_Then_Stopped()
         {
             // Given
             runningOpMode = cc.SelectOperationMode("OpModeOne");
-            await cc.ResetAndWaitForIdle(SENDER);
-            
+            cc.Abort(SENDER);
+
             // When
-            await cc.StartAndWaitForExecute(SENDER);
+            await cc.StopAndWaitForStopped(SENDER);
 
             // Then
-            Assert.AreEqual(ExecutionState.EXECUTE, cc.EXST);
+            Assert.AreEqual(ExecutionState.STOPPED, cc.EXST);
         }
 
         [Test]
-        public async Task Given_Idle_When_StopAndNotFree_Then_StoppedAndOccupied()
+        public async Task Given_Clearing_When_StopAndWaitForStopped_Then_Stopped()
         {
             // Given
             runningOpMode = cc.SelectOperationMode("OpModeOne");
-            await cc.ResetAndWaitForIdle(SENDER);
-            
+            await cc.AbortAndWaitForAborted(SENDER);
+            cc.Clear(SENDER);
+
             // When
             await cc.StopAndWaitForStopped(SENDER);
 
             // Then
-            Assert.AreEqual(SENDER, cc.OCCUPIER);
             Assert.AreEqual(ExecutionState.STOPPED, cc.EXST);
         }
 
         [Test]
-        public async Task Given_Idle_When_StopAndFree_Then_StoppedAndFree()
+        public async Task Given_Idle_When_Start_Then_Execute()
+        {
+            // Given
+            runningOpMode = cc.SelectOperationMode("OpModeOne");
+            await cc.ResetAndWaitForIdle(SENDER);
+            
+            // When
+            await cc.StartAndWaitForExecute(SENDER);
+
+            // Then
+            Assert.AreEqual(ExecutionState.EXECUTE, cc.EXST);
+        }
+
+        [Test]
+        public async Task Given_Idle_When_Stop_Then_Stopped()
         {
             // Given
             runningOpMode = cc.SelectOperationMode("OpModeOne");
@@ -105,21 +119,18 @@ namespace ControlComponents.Core.Tests
             
             // When
             await cc.StopAndWaitForStopped(SENDER);
-            cc.Free(SENDER);
 
             // Then
-            Assert.AreEqual("NONE", cc.OCCUPIER);
             Assert.AreEqual(ExecutionState.STOPPED, cc.EXST);
         }
 
         [Test]
-        public async Task Given_StoppedAndNoOpModeSelected_When_StopAndFree_Then_StoppedAndFree()
+        public async Task Given_StoppedAndNoOpModeSelected_When_Stop_Then_Stopped()
         {
             // Given
             
             // When
             await cc.StopAndWaitForStopped(SENDER);
-            cc.Free(SENDER);
 
             // Then
             Assert.AreEqual("NONE", cc.OCCUPIER);
@@ -155,6 +166,22 @@ namespace ControlComponents.Core.Tests
             Assert.AreEqual(ExecutionState.SUSPENDED, cc.EXST);
         }
 
+        [Test]
+        public async Task Given_Suspended_When_UnsuspendAndWaitForExecute_Then_Execute()
+        {
+            // Given
+            runningOpMode = cc.SelectOperationMode("OpModeOne");
+            await cc.ResetAndWaitForIdle(SENDER);
+            await cc.StartAndWaitForExecute(SENDER);
+            await cc.SuspendAndWaitForSuspended(SENDER);
+
+            // When
+            await cc.UnsuspendAndWaitForExecute(SENDER);
+
+            // Then
+            Assert.AreEqual(ExecutionState.EXECUTE, cc.EXST);
+        }
+
         [Test]
         public async Task Given_Execute_When_HoldAndWaitForHeld_Then_Held()
         {
@@ -215,5 +242,20 @@ namespace ControlComponents.Core.Tests
             await cc.AbortAndWaitForAborted(SENDER);
             cc.EXST.Should().Be(ExecutionState.ABORTED);
         }
+
+        [Test]
+        public async Task Given_OccupiedAndIdle_When_StopPrioByOtherComponent_Then_StoppedAndOccupiedByOtherCompnent()
+        {
+            // Given
+            runningOpMode = cc.SelectOperationMode("OpModeOne");
+            await cc.ResetAndWaitForIdle(SENDER);
+            
+            // When
+            await cc.StopPrioAndWaitForStopped("OTHER");
+
+            // Then
+            Assert.AreEqual(ExecutionState.STOPPED, cc.EXST);
+            Assert.AreEqual("OTHER", cc.OCCUPIER);
+        }
     }
 }
\ No newline at end of file

tests/ControlComponents.Core.Tests/OrderOutputIsSetTests.cs

+using System.Collections.ObjectModel;
+using NUnit.Framework;
+using Moq;
+using NLog;
+using FluentAssertions;
+
+namespace ControlComponents.Core.Tests
+{
+    public class OrderOutputIsSetTests
+    {
+        string ROLE = "ROLE";
+        string SENDER = "SENDER";
+        string CC = "CC";
+        string OpModeOne = "OpModeOne";
+        string OpModeTwo = "OpModeTwo";
+        ControlComponent cc;
+        IOrderOutput output;
+        IOrderOutput outputOne;
+        IOrderOutput outputTwo;
+
+        [OneTimeSetUp]
+        public void OneTimeSetUp()
+        {
+            var config = new NLog.Config.LoggingConfiguration();
+            // Targets where to log to: Console
+            var logconsole = new NLog.Targets.ConsoleTarget("logconsole");
+            logconsole.Layout = new NLog.Layouts.SimpleLayout("${longdate} ${message} ${exception:format=ToString}");
+            // Rules for mapping loggers to targets            
+            config.AddRule(LogLevel.Debug, LogLevel.Fatal, logconsole);
+            // Apply config           
+            NLog.LogManager.Configuration = config;
+        }
+
+        [SetUp]
+        public void Setup()
+        {
+            ControlComponentProvider provider = new ControlComponentProvider();
+            var CascadeOpModes = new Collection<IOperationMode>() { new OperationModeCascade(OpModeOne), new OperationModeCascade(OpModeTwo) };
+            var OpModes = new Collection<IOperationMode>() { new OperationMode(OpModeOne), new OperationMode(OpModeTwo) };
+
+            var cc1 = new ControlComponent("CC1", OpModes, new Collection<IOrderOutput>(), new Collection<string>());
+            var cc2 = new ControlComponent("CC2", OpModes, new Collection<IOrderOutput>(), new Collection<string>());
+            provider.Add("CC1", cc1);
+            provider.Add("CC2", cc2);
+
+            outputOne = new OrderOutput("ROLE_ONE", CC, provider, cc1);
+            outputTwo = new OrderOutput("ROLE_TWO", CC, provider, cc2);
+            Collection<IOrderOutput> orderOutputs = new Collection<IOrderOutput>()
+            {
+                outputOne,
+                outputTwo
+            };
+            cc = new ControlComponent(CC, CascadeOpModes, orderOutputs, new Collection<string>());
+            output = new OrderOutput(ROLE, CC, provider, cc);
+        }
+
+        [Test]
+        public void When_OCCUPIER_Then_Return()
+        {
+            output.OCCUPIER.Should().Be("NONE");
+        }
+        [Test]
+        public void When_ComponentName_Then_Return()
+        {
+            output.ComponentName.Should().Be(CC);
+        }
+        [Test]
+        public void When_WORKST_Then_Return()
+        {
+            output.WORKST.Should().Be("BSTATE");
+        }
+
+        [Test]
+        public void When_ChangeOutput_Then_OutputOfControlComponentChanged()
+        {
+            output.ChangeOutput("ROLE_ONE", "CC2");
+            outputOne.ComponentName.Should().Be("CC2");
+            output.ChangeOutput("ROLE_TWO", "CC1");
+            outputTwo.ComponentName.Should().Be("CC1");
+        }
+        [Test]
+        public void When_ClearOutput_Then_OutputOfControlComponentCleared()
+        {
+            output.ClearOutput("ROLE_ONE");
+            outputOne.IsSet.Should().BeFalse();
+        }
+
+        [Test]
+        public void When_ChangeOutputViaCallMethod_Then_OutputOfControlComponentChanged()
+        {
+            bool success = output.CallMethod<string,string,bool>("", nameof(output.ChangeOutput), "ROLE_ONE", "CC2");
+            success.Should().BeTrue();
+            outputOne.ComponentName.Should().Be("CC2");
+        }
+    }
+}
\ No newline at end of file

tests/ControlComponents.Core.Tests/OrderOutputNotSetTests.cs

@@ -12,11 +12,7 @@ namespace ControlComponents.Core.Tests
         string SENDER = "SENDER";
         string CC = "CC";
         string OpModeOne = "OpModeOne";
-        string OpModeTwo = "OpModeTwo";
-        ControlComponent cc;
-        Collection<IOrderOutput> orderOutputs;
-
-        Mock<IControlComponentProvider> provider;
+        IOrderOutput output;
 
         [OneTimeSetUp]
         public void OneTimeSetUp()
@@ -34,38 +30,25 @@ namespace ControlComponents.Core.Tests
         [SetUp]
         public void Setup()
         {
-            provider = new Mock<IControlComponentProvider>();
-            var CascadeOpModes = new Collection<IOperationMode>() { new OperationModeCascade(OpModeOne), new OperationModeCascade(OpModeTwo) };
-            var OpModes = new Collection<IOperationMode>() { new OperationMode(OpModeOne), new OperationMode(OpModeTwo) };
-            orderOutputs = new Collection<IOrderOutput>()
-            {
-                new OrderOutput("ROLE_ONE", CC, provider.Object, new ControlComponent("CC1", OpModes, new Collection<IOrderOutput>(), new Collection<string>())),
-                new OrderOutput("ROLE_TWO", CC, provider.Object, new ControlComponent("CC2", OpModes, new Collection<IOrderOutput>(), new Collection<string>()))
-            };
-            cc = new ControlComponent(CC, CascadeOpModes, orderOutputs, new Collection<string>());
+            var provider = new Mock<IControlComponentProvider>();
+            output = new OrderOutput(ROLE, CC, provider.Object);
         }
 
         [Test]
         public void When_OCCUPIER_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.OCCUPIER)
                 .Should().Throw<OrderOutputException>();
         }
         [Test]
         public void When_ComponentName_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.ComponentName)
                 .Should().Throw<OrderOutputException>();
         }
         [Test]
         public void When_WORKST_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.WORKST)
                 .Should().Throw<OrderOutputException>();
         }
@@ -74,8 +57,6 @@ namespace ControlComponents.Core.Tests
         [Test]
         public void When_SelectOperationMode_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.SelectOperationMode(OpModeOne))
                 .Should().Throw<OrderOutputException>();
         }
@@ -83,81 +64,61 @@ namespace ControlComponents.Core.Tests
         [Test]
         public void When_DeselectOperationMode_Then_TaskCompleted()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.DeselectOperationMode())
                 .Should().NotThrow();
         }
-        
+
         [Test]
         public void When_Reset_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.Reset(CC))
                 .Should().Throw<OrderOutputException>();
         }
         [Test]
         public void When_Start_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.Start(CC))
                 .Should().Throw<OrderOutputException>();
         }
         [Test]
         public void When_Stop_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.Stop(CC))
                 .Should().Throw<OrderOutputException>();
         }
         [Test]
         public void When_Suspend_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.Suspend(CC))
                 .Should().Throw<OrderOutputException>();
         }
         [Test]
         public void When_Unsuspend_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.Unsuspend(CC))
                 .Should().Throw<OrderOutputException>();
         }
         [Test]
         public void When_Hold_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.Hold(CC))
                 .Should().Throw<OrderOutputException>();
         }
         [Test]
         public void When_Unhold_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.Unhold(CC))
                 .Should().Throw<OrderOutputException>();
         }
         [Test]
         public void When_Abort_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.Abort(CC))
                 .Should().Throw<OrderOutputException>();
         }
         [Test]
         public void When_Clear_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.Clear(CC))
                 .Should().Throw<OrderOutputException>();
         }
@@ -167,62 +128,50 @@ namespace ControlComponents.Core.Tests
         [Test]
         public void When_ReadProperty_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
-            output.Invoking(o => o.ReadProperty<int>(CC,CC))
+            output.Invoking(o => o.ReadProperty<int>(CC, CC))
                 .Should().Throw<OrderOutputException>();
         }
 
         [Test]
         public void When_CallMethod_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
-            output.Invoking(o => o.CallMethod(CC,CC))
+            output.Invoking(o => o.CallMethod(CC, CC))
                 .Should().Throw<OrderOutputException>();
 
-            output.Invoking(o => o.CallMethod<int>(CC,CC, 1))
+            output.Invoking(o => o.CallMethod<int>(CC, CC, 1))
                 .Should().Throw<OrderOutputException>();
 
-            output.Invoking(o => o.CallMethod<int>(CC,CC))
+            output.Invoking(o => o.CallMethod<int>(CC, CC))
                 .Should().Throw<OrderOutputException>();
 
-            output.Invoking(o => o.CallMethod<int, int>(CC,CC, 1))
+            output.Invoking(o => o.CallMethod<int, int>(CC, CC, 1))
                 .Should().Throw<OrderOutputException>();
 
-            output.Invoking(o => o.CallMethod<int, int, int>(CC,CC, 1, 1))
+            output.Invoking(o => o.CallMethod<int, int, int>(CC, CC, 1, 1))
                 .Should().Throw<OrderOutputException>();
         }
 
         [Test]
         public void When_ChangeOutput_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
-            output.Invoking(o => o.ChangeOutput(CC,CC))
+            output.Invoking(o => o.ChangeOutput(CC, CC))
                 .Should().Throw<OrderOutputException>();
         }
         [Test]
         public void When_ClearOutput_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.ClearOutput(CC))
                 .Should().Throw<OrderOutputException>();
         }
         [Test]
         public void When_Auto_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.Auto(CC))
                 .Should().Throw<OrderOutputException>();
         }
         [Test]
         public void When_SemiAuto_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.SemiAuto(CC))
                 .Should().Throw<OrderOutputException>();
         }
@@ -230,66 +179,53 @@ namespace ControlComponents.Core.Tests
         [Test]
         public void When_Occupy_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.Occupy(CC))
                 .Should().Throw<OrderOutputException>();
         }
         [Test]
         public void When_Prio_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.Prio(CC))
                 .Should().Throw<OrderOutputException>();
         }
         [Test]
         public void When_Free_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.Free(CC))
                 .Should().Throw<OrderOutputException>();
         }
 
-
         [Test]
         public void When_EXST_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.EXST)
                 .Should().Throw<OrderOutputException>();
         }
+
         [Test]
         public void When_EXMODE_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.EXMODE)
                 .Should().Throw<OrderOutputException>();
         }
+
         [Test]
         public void When_OpModeName_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.OpModeName)
                 .Should().Throw<OrderOutputException>();
         }
+
         [Test]
         public void When_OpModes_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.OpModes)
                 .Should().Throw<OrderOutputException>();
         }
+
         [Test]
         public void When_Roles_Then_Throw()
         {
-            IOrderOutput output = new OrderOutput(ROLE, CC, provider.Object);
-
             output.Invoking(o => o.Roles)
                 .Should().Throw<OrderOutputException>();
         }

tests/ControlComponents.Core.Tests/OrderOutputTests.cs

@@ -7,6 +7,7 @@ using NUnit.Framework;
 using Moq;
 using NLog;
 using System.Linq;
+using FluentAssertions;
 
 namespace ControlComponents.Core.Tests
 {
@@ -72,6 +73,15 @@ namespace ControlComponents.Core.Tests
             Assert.AreNotEqual(first,second);
         }
 
+        [Test]
+        public void Given_Null_When_Equals_Then_ReturnFalse()
+        {
+            var first = new OrderOutput("ROLE_ONE", "Output", provider.Object, new ControlComponent("CC1", new Collection<IOperationMode>(), new Collection<IOrderOutput>(), new Collection<string>()));
+
+            Assert.AreNotEqual(first,null);
+            Assert.AreNotEqual(first,provider.Object);
+        }
+
         [Test]
         public void Given_OpModes_When_ListOpModeNames_Then_ReturnOpModeNames()
         {
@@ -92,6 +102,20 @@ namespace ControlComponents.Core.Tests
             Assert.AreEqual(ExecutionState.STOPPED, orderOutput.EXST);
         }
 
+        [Test]
+        public void Given_OrderOutput_When_EXMODE_Then_AUTO()
+        {
+            OrderOutput orderOutput = new OrderOutput(ROLE, "Output", provider.Object, cc);
+            Assert.AreEqual(ExecutionMode.AUTO, orderOutput.EXMODE);
+        }
+
+        [Test]
+        public void Given_OrderOutput_When_WORKST_Then_AUTO()
+        {
+            OrderOutput orderOutput = new OrderOutput(ROLE, "Output", provider.Object, cc);
+            Assert.AreEqual("BSTATE", orderOutput.WORKST);
+        }
+
         [Test]
         public void Given_OrderOutputs_When_Roles_Then_Roles()
         {
@@ -161,7 +185,7 @@ namespace ControlComponents.Core.Tests
             Assert.AreEqual("NONE", orderOutputs[1].OpModeName);
         }
 
-        // TODO this tests seems to be not reliable
+        // TODO this test seems to be not reliable
         [Test]
         public async Task Given_Idle_When_Start_Then_Completed()
         {
@@ -193,6 +217,33 @@ namespace ControlComponents.Core.Tests
             await runningOpMode;
         }
 
+        [Test]
+        public async Task Given_Exceute_When_Abort_Then_Aborted()
+        {
+            // Given
+            Task runningOpMode = cc.SelectOperationMode(OpModeOne);
+            await cc.ResetAndWaitForIdle(SENDER);
+            await cc.StartAndWaitForExecute(SENDER);
+
+            // When
+            cc.Abort(SENDER);
+
+            // Then
+            await Helper.WaitForState(orderOutputs[0], ExecutionState.ABORTED);
+            await Helper.WaitForState(orderOutputs[1], ExecutionState.ABORTED);
+            Assert.AreEqual(ExecutionState.ABORTED, orderOutputs[0].EXST);
+            Assert.AreEqual(ExecutionState.ABORTED, orderOutputs[1].EXST);
+
+            await Helper.WaitForState(cc, ExecutionState.ABORTED);
+            Assert.AreEqual(ExecutionState.ABORTED, cc.EXST);
+
+            // Clean Up
+            cc.Clear(SENDER);
+            await Helper.WaitForState(cc, ExecutionState.STOPPED);
+            await cc.DeselectOperationMode();
+            await runningOpMode;
+        }
+
         [Test]
         public void Given_Stopped_When_Change_CC_Then_Changed()
         {
@@ -295,7 +346,32 @@ namespace ControlComponents.Core.Tests
             Assert.AreEqual("CC1", orderOutput.ComponentName);
             cc.ChangeOutput("ROLE_ONE", "CC3");
             Assert.AreEqual("CC3", orderOutput.ComponentName);
+        }
+
+
+        [Test]
+        public async Task When_SubscribeAndUnsubcribe_Then_ReceiveCorrectEvents()
+        {
+            var output = new OrderOutput("ROLE", CC, provider.Object, cc);
+            int i = 0;
+            ExecutionStateEventHandler handler = (object sender, ExecutionStateEventArgs e) => i++;
+            output.Subscribe<ExecutionStateEventHandler>(
+                "ROLE",
+                nameof(output.ExecutionStateChanged),
+                handler);
+
+            Task running = cc.SelectOperationMode(OpModeOne);
+            await cc.ResetAndWaitForIdle(SENDER);
+
+            output.Unsubscribe<ExecutionStateEventHandler>(
+                "ROLE",
+                nameof(output.ExecutionStateChanged),
+                handler);
+
+            await cc.StopAndWaitForStopped(SENDER);
+            await cc.DeselectOperationMode();
 
+            i.Should().Be(2);
         }
     }
 }
\ No newline at end of file

tests/ControlComponents.Protocols.Tests/ControlComponentHttpTests.cs

@@ -121,7 +121,7 @@ namespace ControlComponents.Protocols.Tests
                     .Returns(Task.FromResult(new WebSocketReceiveResult(bytes.Length, WebSocketMessageType.Text, true)));
             
             // Wait for a message of the websocket
-            await Task.Delay(1000, t.Token).ContinueWith(t => Task.Delay(1));
+            await Task.Delay(5000, t.Token).ContinueWith(t => Task.Delay(1));
             i.Should().Be(1);
         }