init

DataPRO/StateMachine.Tests/.svn/entries

@@ -0,0 +1 @@
+12

DataPRO/StateMachine.Tests/.svn/format

@@ -0,0 +1 @@
+12

DataPRO/StateMachine.Tests/.svn/pristine/27/277de18f3e02e8e96c265face570693cd92a1c56.svn-base

@@ -0,0 +1,24 @@
+using DTS.DASLib.Service.StateMachine;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StateMachine.Tests
+{
+    [TestFixture]
+    public class RealtimeShould
+    {
+        [Test]
+        public void State_ShouldBeRealtime()
+        {
+            //Arrange
+            var sut = new Realtime();
+
+            //Act & Assert
+            Assert.That(State.Realtime, Is.EqualTo(sut.State));
+        }
+    }
+}

DataPRO/StateMachine.Tests/.svn/pristine/32/32bf41b848472f9f4d28197e25687a8eab30adbd.svn-base

@@ -0,0 +1,27 @@
+using DTS.DASLib.Service.StateMachine;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StateMachine.Tests
+{
+    [TestFixture]
+    public class ConfigureShould
+    {
+        [Test]
+        public void StateSelector_Should_ReturnConfigureStart()
+        {
+            //Arrange
+            var sut = new Configure();
+
+            //Act
+            var dasState = sut.StateSelector();
+
+            // Assert
+            Assert.That(dasState.State, Is.EqualTo(State.ConfigureStart));
+        }
+    }
+}

DataPRO/StateMachine.Tests/.svn/pristine/5d/5dc772f86c78a71a2439d71bb05d821550e2c73b.svn-base

@@ -0,0 +1,134 @@
+using DTS.DASLib.Service.StateMachine;
+using NSubstitute;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StateMachine.Tests
+{
+    [TestFixture]
+    class HardwareDiscoveryStartShould
+    {
+        [Test]
+        public void State_ShouldBeHardwareDiscoveryStart()
+        {
+            //Arrange
+            var sut = new HardwareDiscoveryStart();
+
+            //Act & Assert
+            Assert.That(State.HardwareDiscoveryStart, Is.EqualTo(sut.State));
+        }
+
+        [Test]
+        public void StateSelector_Should_ReturnConfigure()
+        {
+            //Arrange
+            var sut = new HardwareDiscoveryStart();
+            var status = sut.Status;
+            status.HardwareDiscoveryParams.ProceedWhenDone = true;
+
+            status.HardwareDiscoveryStatusInfo.AllDASFound = true;
+            status.HardwareDiscoveryParams.RequireAllDASFound = true;
+
+            //Act
+            var dasState = sut.StateSelector();
+
+            //Assert
+            Assert.That(dasState.State, Is.EqualTo(State.Configure));
+
+            //Arrange
+            status.HardwareDiscoveryParams.ProceedWhenDone = true;
+
+            status.HardwareDiscoveryStatusInfo.AllDASFound = true;
+            status.HardwareDiscoveryParams.RequireAllDASFound = false;
+
+            //Act
+            dasState = sut.StateSelector();
+
+            //Assert
+            Assert.That(dasState.State, Is.EqualTo(State.Configure));
+
+            //Arrange
+            status.HardwareDiscoveryParams.ProceedWhenDone = true;
+
+            status.HardwareDiscoveryStatusInfo.AllDASFound = false;
+            status.HardwareDiscoveryParams.RequireAllDASFound = false;
+
+            //Act
+            dasState = sut.StateSelector();
+
+            //Assert
+            Assert.That(dasState.State, Is.EqualTo(State.Configure));
+        }
+
+        [Test]
+        public void StateSelector_Should_ReturnDownload()
+        {
+            //Arrange
+            var sut = new HardwareDiscoveryStart();
+            var status = sut.Status;
+            status.HardwareDiscoveryParams.ProceedWhenDone = true;
+
+            status.HardwareDiscoveryStatusInfo.AllDASFound = true;
+            status.HardwareDiscoveryParams.RequireAllDASFound = true;
+
+            status.HardwareDiscoveryParams.GoToDownload = true;
+
+            //Act
+            var dasState = sut.StateSelector();
+            //Assert
+            Assert.That(dasState.State, Is.EqualTo(State.Download));
+        }
+
+        [Test]
+        public void StateSelector_Should_ReturnArm()
+        {
+            //Arrange
+            var sut = new HardwareDiscoveryStart();
+            var status = sut.Status;
+
+            status.HardwareDiscoveryParams.ProceedWhenDone = true;
+            //Cannot Configure
+            status.HardwareDiscoveryStatusInfo.AllDASFound = false;
+            status.HardwareDiscoveryParams.RequireAllDASFound = true;
+
+            //Cannot Download 
+            status.HardwareDiscoveryParams.GoToDownload = false;
+
+            //Can Arm
+            status.HardwareDiscoveryStatusInfo.SomeUnitsInArmState = true;
+
+            //Act
+            var dasState = sut.StateSelector();
+            // Assert
+            Assert.That(dasState.State, Is.EqualTo(State.Arm));
+        }
+
+        [Test]
+        public void StateSelector_Should_ReturnHardwareDiscovery()
+        {
+            //Arrange
+            var sut = new HardwareDiscoveryStart();
+            var status = sut.Status;
+
+            status.HardwareDiscoveryParams.ProceedWhenDone = true;
+            //Cannot Configure
+            status.HardwareDiscoveryStatusInfo.AllDASFound = false;
+            status.HardwareDiscoveryParams.RequireAllDASFound = true;
+
+            //Cannot Download 
+            status.HardwareDiscoveryParams.GoToDownload = false;
+
+            //Can Arm
+            status.HardwareDiscoveryStatusInfo.SomeUnitsInArmState = false;
+
+            //Act
+            var dasState = sut.StateSelector();
+            // Assert
+            Assert.That(dasState.State, Is.EqualTo(State.HardwareDiscovery));
+        }
+    }
+}

DataPRO/StateMachine.Tests/.svn/pristine/70/70e4ef4ef8e137575fb8db6b3fcb57a82865a722.svn-base

@@ -0,0 +1,89 @@
+using DTS.DASLib.Service.StateMachine;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StateMachine.Tests
+{
+    [TestFixture]
+    public class DiagnoseShould
+    {
+        [Test]
+        public void State_ShouldBeRealtime()
+        {
+            //Arrange
+            var sut = new Realtime();
+
+            //Act & Assert
+            Assert.That(State.Realtime, Is.EqualTo(sut.State));
+        }
+
+        [Test]
+        public void StateSelector_ShouldReturnRealtime_WhenRequireAllUnitsPassDiagnosticIsFalse()
+        {
+            //Arrange
+            var sut = new Diagnose();
+            var status = sut.Status;
+            status.DiagnoseParams.ProceedToRealtimeWhenDone = true;
+            status.DiagnoseParams.RequireAllUnitsPassDiagnostic = false;
+
+            //Act
+            var dasState = sut.StateSelector();
+
+            // Assert
+            Assert.That(dasState.State, Is.EqualTo(State.RealtimeStart));
+        }
+
+        [Test]
+        public void StateSelector_ShouldReturnRealtime_WhenAllUnitsPassedDiagnostic()
+        {
+            //Arrange
+            var sut = new Diagnose();
+            var status = sut.Status;
+            status.DiagnoseParams.ProceedToRealtimeWhenDone = true;
+            status.DiagnoseParams.AllUnitsPassedDiagnostic = true;
+
+            //Act
+            var dasState = sut.StateSelector();
+
+            // Assert
+            Assert.That(dasState.State, Is.EqualTo(State.RealtimeStart));
+        }
+        [Test]
+        public void StateSelector_ShouldReturnDiagnose_ProceedToRealtimeWhenDoneIsFalse()
+        {
+            //Arrange
+            var sut = new Diagnose();
+            var status = sut.Status;
+            status.DiagnoseParams.ProceedToRealtimeWhenDone = false;
+            status.DiagnoseParams.AllUnitsPassedDiagnostic = true;
+            status.DiagnoseParams.RequireAllUnitsPassDiagnostic = false;
+
+            //Act
+            var dasState = sut.StateSelector();
+
+            // Assert
+            Assert.That(dasState.State, Is.EqualTo(State.Diagnose));
+        }
+
+        [Test]
+        public void StateSelector_ShouldReturnDiagnose_WhenAllUnitsPassedDiagnosticIsFalseAndRequireAllUnitsPassDiagnostic()
+        {
+            //Arrange
+            var sut = new Diagnose();
+            var status = sut.Status;
+            status.DiagnoseParams.ProceedToRealtimeWhenDone = true;
+            status.DiagnoseParams.RequireAllUnitsPassDiagnostic = true;
+            status.DiagnoseParams.AllUnitsPassedDiagnostic = false;
+
+            //Act
+            var dasState = sut.StateSelector();
+
+            // Assert
+            Assert.That(dasState.State, Is.EqualTo(State.Diagnose));
+        }
+    }
+}

DataPRO/StateMachine.Tests/.svn/pristine/76/76775a3f7543583d8b8de6aafe6143ef8a37ac4c.svn-base

@@ -0,0 +1,79 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="..\packages\NUnit3TestAdapter.3.14.0\build\net35\NUnit3TestAdapter.props" Condition="Exists('..\packages\NUnit3TestAdapter.3.14.0\build\net35\NUnit3TestAdapter.props')" />
+  <Import Project="..\packages\NUnit.3.12.0\build\NUnit.props" Condition="Exists('..\packages\NUnit.3.12.0\build\NUnit.props')" />
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{A535DD8A-4959-4FFC-827F-06F7EE345EFD}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>StateMachine.Tests</RootNamespace>
+    <AssemblyName>StateMachine.Tests</AssemblyName>
+    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <Deterministic>true</Deterministic>
+    <NuGetPackageImportStamp>
+    </NuGetPackageImportStamp>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Castle.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
+      <HintPath>..\packages\Castle.Core.4.4.0\lib\net45\Castle.Core.dll</HintPath>
+    </Reference>
+    <Reference Include="NSubstitute, Version=4.2.0.0, Culture=neutral, PublicKeyToken=92dd2e9066daa5ca, processorArchitecture=MSIL">
+      <HintPath>..\packages\NSubstitute.4.2.1\lib\net46\NSubstitute.dll</HintPath>
+    </Reference>
+    <Reference Include="nunit.framework, Version=3.12.0.0, Culture=neutral, PublicKeyToken=2638cd05610744eb, processorArchitecture=MSIL">
+      <HintPath>..\packages\NUnit.3.12.0\lib\net45\nunit.framework.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Configuration" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Runtime.CompilerServices.Unsafe, Version=4.0.4.1, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.Runtime.CompilerServices.Unsafe.4.5.2\lib\netstandard2.0\System.Runtime.CompilerServices.Unsafe.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Threading.Tasks.Extensions, Version=4.2.0.1, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.Threading.Tasks.Extensions.4.5.3\lib\netstandard2.0\System.Threading.Tasks.Extensions.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="States\ConfigureShould.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="StatesShould.cs" />
+    <Compile Include="States\DiagnoseShould.cs" />
+    <Compile Include="States\HardwareDiscoveryStartShould.cs" />
+    <Compile Include="States\RealtimeShould.cs" />
+    <Compile Include="States\RealtimeStartShould.cs" />
+    <Compile Include="StatusAndParameters\GlobalStatusInformationShould.cs" />
+    <Compile Include="StatusAndParameters\Realtime\RealtimeStatusInformationShould.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Common\DTS.Common\DTS.Common.csproj">
+      <Project>{f7a0804f-61a4-40ae-83d0-f1137622b592}</Project>
+      <Name>DTS.Common</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\IService\IService.csproj">
+      <Project>{c9c45b72-05a3-4962-bc13-a78b1f4b1925}</Project>
+      <Name>IService</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup />
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\packages\NUnit.3.12.0\build\NUnit.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\NUnit.3.12.0\build\NUnit.props'))" />
+    <Error Condition="!Exists('..\packages\NUnit3TestAdapter.3.14.0\build\net35\NUnit3TestAdapter.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\NUnit3TestAdapter.3.14.0\build\net35\NUnit3TestAdapter.props'))" />
+  </Target>
+</Project>

DataPRO/StateMachine.Tests/.svn/pristine/93/9370db5f89d3bb3bfe03b1d9435a8d964190b1b0.svn-base

@@ -0,0 +1,114 @@
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using DTS.DASLib.Service.StateMachine;
+using NSubstitute;
+using DTS.Common.Interface.DASFactory;
+
+namespace StateMachine.Tests
+{
+    [TestFixture]
+    public class StatesShould
+    {
+        [Test]
+        public void Instance_ShouldNotBeNull()
+        {
+            //Arrange
+            var sut = States.Instance;
+
+            //Act && Assert
+            Assert.That(sut, Is.Not.Null);
+        }
+
+        [Test]
+        public void Instance_ShouldBeSame()
+        {
+            //Arrange
+            var sut = States.Instance;
+
+            //Act && Assert
+            Assert.That(sut, Is.Not.Null.And.SameAs(States.Instance));
+        }
+
+        [Test]
+        public void States_ShouldReturnCorrectInstanceOfState()
+        {
+            //Arrange
+            var sut = States.Instance;
+
+            //Act && Assert
+            Assert.That(sut.Arm.State, Is.EqualTo(State.Arm));
+            Assert.That(sut.Arming.State, Is.EqualTo(State.Arming));
+            Assert.That(sut.Configure.State, Is.EqualTo(State.Configure));
+            Assert.That(sut.ConfigureStart.State, Is.EqualTo(State.ConfigureStart));
+            Assert.That(sut.Diagnose.State, Is.EqualTo(State.Diagnose));
+            Assert.That(sut.Download.State, Is.EqualTo(State.Download));
+            Assert.That(sut.HardwareDiscovery.State, Is.EqualTo(State.HardwareDiscovery));
+            Assert.That(sut.HardwareDiscoveryStart.State, Is.EqualTo(State.HardwareDiscoveryStart));
+            Assert.That(sut.Prepare.State, Is.EqualTo(State.Prepare));
+            Assert.That(sut.Realtime.State, Is.EqualTo(State.Realtime));
+            Assert.That(sut.RealtimeStart.State, Is.EqualTo(State.RealtimeStart));
+        }
+
+        [Test]
+        public void GetIDASState_ReturnAllKnownStates()
+        {
+            //Arrange
+            var sut = States.Instance;
+
+            //Act & Assert
+            var states = Enum.GetValues(typeof(State)).Cast<State>();
+            foreach (var state in states)
+            {
+                var dasState = sut.GetIDASState(state);
+                Assert.That(dasState.State, Is.EqualTo(state));
+            }
+        }
+
+        [Test]
+        public void GetIDASState_ShouldThrowException_WithUndefinedState()
+        {
+            //Arrange
+            var sut = States.Instance;
+            var enumVal = 45;
+
+            //Act & Assert
+            Assert.That(false, Is.EqualTo(Enum.IsDefined(typeof(State), enumVal)));
+            Assert.That(
+                () => sut.GetIDASState((State)enumVal)
+                , Throws.TypeOf<InvalidOperationException>()
+           .With
+           .Property("Message")
+           .EqualTo("Undefined State"));
+        }
+
+        [Test]
+        public void SetDASFactory_ShouldSetToAnInstanceOfDASFactory()
+        {
+            //Arrange
+            var sut = States.Instance;
+            var dasFactory = Substitute.For<IDASFactory>();
+            dasFactory.Language.Returns("En");
+
+            //Act
+            States.SetDASFactory(dasFactory);
+
+            //Assert
+            //Test thal all states have the defined DASFactory instance.
+            var states = Enum.GetValues(typeof(State)).Cast<State>();
+            foreach (var state in states)
+            {
+                //Depends on GetIDASState_ReturnAllKnownStates , If this test broken first fix GetIDASState_ReturnAllKnownStates
+                //Isolate the dependency to the GetIDASState_ReturnAllKnownStates test if it's possible
+                var dasState = sut.GetIDASState(state);
+                Assert.That(dasState.DASFactory, Is.Not.Null);
+                Assert.That(dasState.DASFactory.Language, Is.EqualTo("En"));
+            }
+
+
+        }
+    }
+}

DataPRO/StateMachine.Tests/.svn/pristine/b8/b85ae47a69000f5fe18d7e42f7482e2539b42aff.svn-base

@@ -0,0 +1,42 @@
+using DTS.DASLib.Service.StateMachine;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StateMachine.Tests
+{
+    [TestFixture]
+    public class RealtimeStartShould
+    {
+        [Test]
+        public void StateSelector_Should_ReturnRealtimeStart()
+        {
+            //Arrange
+            var sut = new RealtimeStart();
+            var status = sut.Status;
+            status.RealtimeStatus.CouldNotStartRealtime = true;
+
+            //Act
+            var dasState = sut.StateSelector();
+            // Assert
+            Assert.That(dasState.State, Is.EqualTo(State.RealtimeStart));
+        }
+
+        [Test]
+        public void StateSelector_Should_ReturnRealtime()
+        {
+            //Arrange
+            var sut = new RealtimeStart();
+            var status = sut.Status;
+            status.RealtimeStatus.CouldNotStartRealtime = false;
+
+            //Act
+            var dasState = sut.StateSelector();
+            // Assert
+            Assert.That(dasState.State, Is.EqualTo(State.Realtime));
+        }
+    }
+}

DataPRO/StateMachine.Tests/.svn/pristine/bb/bbd5c2a994a22a33a5b958b43ba6fa96b982eb65.svn-base

@@ -0,0 +1,87 @@
+using DTS.Common.Interface.DASFactory;
+using DTS.DASLib.Service;
+using DTS.DASLib.Service.StateMachine;
+using NSubstitute;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+
+
+namespace StateMachine.Tests.StatusAndParameters
+{
+    [TestFixture]
+    class RealtimeStatusInformationShould
+    {
+        [Test]
+        public void StartRealtime_Should_CouldNotStartRealtimeBeTrue()
+        {
+
+            //Arrange
+            var sut = new RealtimeStatusInformation();
+            var das = Substitute.For<IDASCommunication>();
+
+            var dasList = new List<IDASCommunication> { das };
+
+            var indices = new List<int>();
+            indices.Add(0);
+            var moduleIndices = indices;
+
+            var useSingleSampleMode = false;
+            var realtimeSampleRate = 1000;
+            var realtimeDelayBetweenPollsInMilliSecond = 4;
+            var allowMultipleSampleRealtime = true;
+
+
+            var b = new byte[1];
+            b[0] = 0;
+            var idasToActiveChannels = new Dictionary<IDASCommunication, byte[]>();
+            idasToActiveChannels.Add(dasList[0], b);
+
+
+            Action CompleteAction = () =>
+            {
+                Console.WriteLine("Realtime started");
+            };
+            Action<double, double> SetRealtimeSampleRateAAF = (p, q) =>
+            {
+                Console.WriteLine("Set RealtimeSampleRateAAF {0},{1}", p, q);
+            };
+
+            ServiceBase.Callback StartRealtimeCallback = (data) =>
+            {
+                if (data.Status == ServiceBase.CallbackData.CallbackStatus.AllFinished)
+                {
+                    Console.WriteLine("Finished receiving data");
+                }
+
+                if (data.Status == ServiceBase.CallbackData.CallbackStatus.NewData)
+                {
+
+                    Console.WriteLine("Receiving new data {0}", data.Data[0].SampleNumber.ToString());
+                }
+            };
+
+            //Act
+            sut.StartRealtime(dasList, moduleIndices, useSingleSampleMode, realtimeSampleRate,
+                realtimeDelayBetweenPollsInMilliSecond, allowMultipleSampleRealtime, SetRealtimeSampleRateAAF, CompleteAction,
+                idasToActiveChannels, StartRealtimeCallback);
+
+            //Assert
+            Assert.That(sut.CouldNotStartRealtime, Is.EqualTo(true));
+
+        }
+
+        [Test]
+        public void IsInRealtime_Should_ReturnFalse()
+        {
+            //Arrange
+            var sut = new RealtimeStatusInformation();
+
+            //Act
+            var result = sut.IsInRealtime;
+
+            //Assert 
+            Assert.That(result, Is.EqualTo(false));
+        }
+    }
+}

DataPRO/StateMachine.Tests/.svn/pristine/c0/c00d31e7942ccde3e31d84b2747545f65698a50e.svn-base

@@ -0,0 +1,438 @@
+using NUnit.Framework;
+using DTS.Common.Interface.DASFactory;
+using DTS.DASLib.Service;
+using DTS.DASLib.Service.StateMachine;
+using NSubstitute;
+using System.Collections.Generic;
+
+namespace StateMachine.Tests.StatusAndParameters
+{
+    [TestFixture]
+    class GlobalStatusInformationShould
+    {
+        GlobalStatusInformation sut;
+
+        [SetUp]
+        public void SetUp()
+        {
+            //Arrange
+            sut = new GlobalStatusInformation();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            sut = null;
+        }
+
+        [Test]
+        public void GetUnitsInRealtime_Should_ReturnNoUnites()
+        {
+            //Act
+            var result = sut.GetUnitsInRealtime();
+
+            //Assert
+            Assert.That(result, Is.EqualTo(new List<IDASCommunication>()));
+            Assert.That(result.Length, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void AddUnitInRealtime_Should_AddUnitCorrectly()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            //Act
+            sut.AddUnitInRealtime(device);
+
+            //Assert
+            Assert.That(sut.GetUnitsInRealtime().Length, Is.EqualTo(1));
+            Assert.That(sut.GetUnitsInRealtime()[0].SerialNumber, Is.EqualTo(sn));
+        }
+
+        [Test]
+        public void AddUnitInRealtime_Should_AddMultipleUnitsCorrectly()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            var secondDevice = Substitute.For<IDASCommunication>();
+            var secondSn = "SL60160";
+            secondDevice.SerialNumber.Returns(secondSn);
+
+            //Act
+            sut.AddUnitInRealtime(device);
+            sut.AddUnitInRealtime(secondDevice);
+
+            //Assert
+            Assert.That(sut.GetUnitsInRealtime().Length, Is.EqualTo(2));
+            Assert.That(sut.GetUnitsInRealtime()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsInRealtime()[1].SerialNumber, Is.EqualTo(secondSn));
+        }
+
+        [Test]
+        public void AddUnitInRealtime_ShouldNot_AddExistingDevice()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            var secondDevice = Substitute.For<IDASCommunication>();
+            var secondSn = "SL60160";
+            secondDevice.SerialNumber.Returns(secondSn);
+
+            var thirdDevice = secondDevice;
+
+            //Act
+            sut.AddUnitInRealtime(device);
+            sut.AddUnitInRealtime(secondDevice);
+            sut.AddUnitInRealtime(thirdDevice);
+
+            //Assert
+            Assert.That(sut.GetUnitsInRealtime().Length, Is.EqualTo(2));
+            Assert.That(sut.GetUnitsInRealtime()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsInRealtime()[1].SerialNumber, Is.EqualTo(secondSn));
+        }
+
+
+        [Test]
+        public void GetUnitsInArm_Should_ReturnNoUnites()
+        {
+            //Act
+            var result = sut.GetUnitsInArm();
+
+            //Assert
+            Assert.That(result, Is.EqualTo(new List<IDASCommunication>()));
+            Assert.That(result.Length, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void AddUnitInArm_Should_AddUnitCorrectly()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            //Act
+            sut.AddUnitInArm(device);
+
+            //Assert
+            Assert.That(sut.GetUnitsInArm().Length, Is.EqualTo(1));
+            Assert.That(sut.GetUnitsInArm()[0].SerialNumber, Is.EqualTo(sn));
+        }
+
+        [Test]
+        public void AddUnitInArm_Should_AddMultipleUnitsCorrectly()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            var secondDevice = Substitute.For<IDASCommunication>();
+            var secondSn = "SL60160";
+            secondDevice.SerialNumber.Returns(secondSn);
+
+            //Act
+            sut.AddUnitInArm(device);
+            sut.AddUnitInArm(secondDevice);
+
+            //Assert
+            Assert.That(sut.GetUnitsInArm().Length, Is.EqualTo(2));
+            Assert.That(sut.GetUnitsInArm()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsInArm()[1].SerialNumber, Is.EqualTo(secondSn));
+        }
+
+        [Test]
+        public void AddUnitInArm_ShouldNot_AddExistingDevice()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            var secondDevice = Substitute.For<IDASCommunication>();
+            var secondSn = "SL60160";
+            secondDevice.SerialNumber.Returns(secondSn);
+
+            var thirdDevice = secondDevice;
+
+            //Act
+            sut.AddUnitInArm(device);
+            sut.AddUnitInArm(secondDevice);
+            sut.AddUnitInArm(thirdDevice);
+
+            //Assert
+            Assert.That(sut.GetUnitsInArm().Length, Is.EqualTo(2));
+            Assert.That(sut.GetUnitsInArm()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsInArm()[1].SerialNumber, Is.EqualTo(secondSn));
+        }
+
+        [Test]
+        public void GetUnitsAtLowPower_Should_ReturnNoUnites()
+        {
+            //Act
+            var result = sut.GetUnitsAtLowPower();
+
+            //Assert
+            Assert.That(result, Is.EqualTo(new List<IDASCommunication>()));
+            Assert.That(result.Length, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void AddUnitAtLowPower_Should_AddUnitCorrectly()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            //Act
+            sut.AddUnitAtLowPower(device);
+
+            //Assert
+            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(1));
+            Assert.That(sut.GetUnitsAtLowPower()[0].SerialNumber, Is.EqualTo(sn));
+        }
+
+        [Test]
+        public void AddUnitAtLowPower_Should_AddMultipleUnitsCorrectly()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            var secondDevice = Substitute.For<IDASCommunication>();
+            var secondSn = "SL60160";
+            secondDevice.SerialNumber.Returns(secondSn);
+
+            //Act
+            sut.AddUnitAtLowPower(device);
+            sut.AddUnitAtLowPower(secondDevice);
+
+            //Assert
+            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(2));
+            Assert.That(sut.GetUnitsAtLowPower()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsAtLowPower()[1].SerialNumber, Is.EqualTo(secondSn));
+        }
+
+        [Test]
+        public void AddUnitAtLowPower_ShouldNot_AddExistingDevice()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            var secondDevice = Substitute.For<IDASCommunication>();
+            var secondSn = "SL60160";
+            secondDevice.SerialNumber.Returns(secondSn);
+
+            var thirdDevice = secondDevice;
+
+            //Act
+            sut.AddUnitAtLowPower(device);
+            sut.AddUnitAtLowPower(secondDevice);
+            sut.AddUnitAtLowPower(thirdDevice);
+
+            //Assert
+            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(2));
+            Assert.That(sut.GetUnitsAtLowPower()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsAtLowPower()[1].SerialNumber, Is.EqualTo(secondSn));
+        }
+
+        [Test]
+        public void AddUnitAtLowPower_Should_AddToLowPowerRemoveFromHighPower()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            var secondDevice = Substitute.For<IDASCommunication>();
+            var secondSn = "SL60160";
+            secondDevice.SerialNumber.Returns(secondSn);
+
+            var thirdDevice = Substitute.For<IDASCommunication>();
+            var thirdSn = "SL60161";
+            thirdDevice.SerialNumber.Returns(thirdSn);
+
+            //Act & Assert
+            sut.AddUnitAtLowPower(device);
+            sut.AddUnitAtLowPower(secondDevice);
+
+            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(2));
+            Assert.That(sut.GetUnitsAtLowPower()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsAtLowPower()[1].SerialNumber, Is.EqualTo(secondSn));
+
+            sut.AddUnitAtHighPower(thirdDevice);
+
+            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(1));
+            Assert.That(sut.GetUnitsAtHighPower()[0].SerialNumber, Is.EqualTo(thirdSn));
+
+            sut.AddUnitAtLowPower(thirdDevice);
+
+            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(3));
+            Assert.That(sut.GetUnitsAtLowPower()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsAtLowPower()[1].SerialNumber, Is.EqualTo(secondSn));
+            Assert.That(sut.GetUnitsAtLowPower()[2].SerialNumber, Is.EqualTo(thirdSn));
+
+            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void GetUnitsAtHighPower_Should_ReturnNoUnites()
+        {
+            //Act
+            var result = sut.GetUnitsAtHighPower();
+
+            //Assert
+            Assert.That(result, Is.EqualTo(new List<IDASCommunication>()));
+            Assert.That(result.Length, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void AddUnitAtHighPower_Should_AddUnitCorrectly()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            //Act
+            sut.AddUnitAtHighPower(device);
+
+            //Assert
+            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(1));
+            Assert.That(sut.GetUnitsAtHighPower()[0].SerialNumber, Is.EqualTo(sn));
+        }
+
+        [Test]
+        public void AddUnitAtHighPower_Should_AddMultipleUnitsCorrectly()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            var secondDevice = Substitute.For<IDASCommunication>();
+            var secondSn = "SL60160";
+            secondDevice.SerialNumber.Returns(secondSn);
+
+            //Act
+            sut.AddUnitAtHighPower(device);
+            sut.AddUnitAtHighPower(secondDevice);
+
+            //Assert
+            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(2));
+            Assert.That(sut.GetUnitsAtHighPower()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsAtHighPower()[1].SerialNumber, Is.EqualTo(secondSn));
+        }
+
+        [Test]
+        public void AddUnitAtHighPower_ShouldNot_AddExistingDevice()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            var secondDevice = Substitute.For<IDASCommunication>();
+            var secondSn = "SL60160";
+            secondDevice.SerialNumber.Returns(secondSn);
+
+            var thirdDevice = secondDevice;
+
+            //Act
+            sut.AddUnitAtHighPower(device);
+            sut.AddUnitAtHighPower(secondDevice);
+            sut.AddUnitAtHighPower(thirdDevice);
+
+            //Assert
+            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(2));
+            Assert.That(sut.GetUnitsAtHighPower()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsAtHighPower()[1].SerialNumber, Is.EqualTo(secondSn));
+        }
+
+
+        [Test]
+        public void AddUnitAtHighPower_Should_AddToLowPowerRemoveFromLowPower()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            var secondDevice = Substitute.For<IDASCommunication>();
+            var secondSn = "SL60160";
+            secondDevice.SerialNumber.Returns(secondSn);
+
+            var thirdDevice = Substitute.For<IDASCommunication>();
+            var thirdSn = "SL60161";
+            thirdDevice.SerialNumber.Returns(thirdSn);
+
+            //Act & Assert
+            sut.AddUnitAtHighPower(device);
+            sut.AddUnitAtHighPower(secondDevice);
+
+            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(2));
+            Assert.That(sut.GetUnitsAtHighPower()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsAtHighPower()[1].SerialNumber, Is.EqualTo(secondSn));
+
+            sut.AddUnitAtLowPower(thirdDevice);
+
+            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(1));
+            Assert.That(sut.GetUnitsAtLowPower()[0].SerialNumber, Is.EqualTo(thirdSn));
+
+            sut.AddUnitAtHighPower(thirdDevice);
+
+            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(3));
+            Assert.That(sut.GetUnitsAtHighPower()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsAtHighPower()[1].SerialNumber, Is.EqualTo(secondSn));
+            Assert.That(sut.GetUnitsAtHighPower()[2].SerialNumber, Is.EqualTo(thirdSn));
+
+            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(0));
+        }
+
+
+        [Test]
+        public void Reset_Should_ResetProperties()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            var device2 = Substitute.For<IDASCommunication>();
+            var sn2 = "SL60160";
+            device2.SerialNumber.Returns(sn2);
+
+            sut.AddUnitAtLowPower(device);
+            sut.AddUnitInArm(device);
+            sut.AddUnitInRealtime(device);
+            sut.AddUnitAtHighPower(device2);
+            sut.ExcitationOn = true;
+
+            //Act & Assert
+            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(1));
+            Assert.That(sut.GetUnitsInArm().Length, Is.EqualTo(1));
+            Assert.That(sut.GetUnitsInRealtime().Length, Is.EqualTo(1));
+            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(1));
+            Assert.That(sut.ExcitationOn, Is.EqualTo(true));
+
+            sut.Reset();
+            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(0));
+            Assert.That(sut.GetUnitsInArm().Length, Is.EqualTo(0));
+            Assert.That(sut.GetUnitsInRealtime().Length, Is.EqualTo(0));
+            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(0));
+            Assert.That(sut.ExcitationOn, Is.EqualTo(false));
+        }
+    }
+}

DataPRO/StateMachine.Tests/.svn/pristine/f7/f707343d6f062166216b3deb295dfb059ef2bf82.svn-base

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Castle.Core" version="4.4.0" targetFramework="net461" />
+  <package id="NSubstitute" version="4.2.1" targetFramework="net461" />
+  <package id="NUnit" version="3.12.0" targetFramework="net461" />
+  <package id="NUnit3TestAdapter" version="3.14.0" targetFramework="net461" />
+  <package id="System.Runtime.CompilerServices.Unsafe" version="4.5.2" targetFramework="net461" />
+  <package id="System.Threading.Tasks.Extensions" version="4.5.3" targetFramework="net461" />
+</packages>

DataPRO/StateMachine.Tests/.svn/pristine/fe/fe0156de576fcfe4431bcca39eeada3d208de079.svn-base

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("IService.Tests")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("IService.Tests")]
+[assembly: AssemblyCopyright("Copyright ©  2019")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("a535dd8a-4959-4ffc-827f-06f7ee345efd")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

DataPRO/StateMachine.Tests/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("IService.Tests")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("IService.Tests")]
+[assembly: AssemblyCopyright("Copyright ©  2019")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("a535dd8a-4959-4ffc-827f-06f7ee345efd")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

DataPRO/StateMachine.Tests/StateMachine.Tests.csproj

@@ -0,0 +1,79 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="..\packages\NUnit3TestAdapter.3.14.0\build\net35\NUnit3TestAdapter.props" Condition="Exists('..\packages\NUnit3TestAdapter.3.14.0\build\net35\NUnit3TestAdapter.props')" />
+  <Import Project="..\packages\NUnit.3.12.0\build\NUnit.props" Condition="Exists('..\packages\NUnit.3.12.0\build\NUnit.props')" />
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{A535DD8A-4959-4FFC-827F-06F7EE345EFD}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>StateMachine.Tests</RootNamespace>
+    <AssemblyName>StateMachine.Tests</AssemblyName>
+    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <Deterministic>true</Deterministic>
+    <NuGetPackageImportStamp>
+    </NuGetPackageImportStamp>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Castle.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
+      <HintPath>..\packages\Castle.Core.4.4.0\lib\net45\Castle.Core.dll</HintPath>
+    </Reference>
+    <Reference Include="NSubstitute, Version=4.2.0.0, Culture=neutral, PublicKeyToken=92dd2e9066daa5ca, processorArchitecture=MSIL">
+      <HintPath>..\packages\NSubstitute.4.2.1\lib\net46\NSubstitute.dll</HintPath>
+    </Reference>
+    <Reference Include="nunit.framework, Version=3.12.0.0, Culture=neutral, PublicKeyToken=2638cd05610744eb, processorArchitecture=MSIL">
+      <HintPath>..\packages\NUnit.3.12.0\lib\net45\nunit.framework.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Configuration" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Runtime.CompilerServices.Unsafe, Version=4.0.4.1, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.Runtime.CompilerServices.Unsafe.4.5.2\lib\netstandard2.0\System.Runtime.CompilerServices.Unsafe.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Threading.Tasks.Extensions, Version=4.2.0.1, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.Threading.Tasks.Extensions.4.5.3\lib\netstandard2.0\System.Threading.Tasks.Extensions.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="States\ConfigureShould.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="StatesShould.cs" />
+    <Compile Include="States\DiagnoseShould.cs" />
+    <Compile Include="States\HardwareDiscoveryStartShould.cs" />
+    <Compile Include="States\RealtimeShould.cs" />
+    <Compile Include="States\RealtimeStartShould.cs" />
+    <Compile Include="StatusAndParameters\GlobalStatusInformationShould.cs" />
+    <Compile Include="StatusAndParameters\Realtime\RealtimeStatusInformationShould.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Common\DTS.Common\DTS.Common.csproj">
+      <Project>{f7a0804f-61a4-40ae-83d0-f1137622b592}</Project>
+      <Name>DTS.Common</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\IService\IService.csproj">
+      <Project>{c9c45b72-05a3-4962-bc13-a78b1f4b1925}</Project>
+      <Name>IService</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup />
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\packages\NUnit.3.12.0\build\NUnit.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\NUnit.3.12.0\build\NUnit.props'))" />
+    <Error Condition="!Exists('..\packages\NUnit3TestAdapter.3.14.0\build\net35\NUnit3TestAdapter.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\NUnit3TestAdapter.3.14.0\build\net35\NUnit3TestAdapter.props'))" />
+  </Target>
+</Project>

DataPRO/StateMachine.Tests/States/ConfigureShould.cs

@@ -0,0 +1,27 @@
+using DTS.DASLib.Service.StateMachine;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StateMachine.Tests
+{
+    [TestFixture]
+    public class ConfigureShould
+    {
+        [Test]
+        public void StateSelector_Should_ReturnConfigureStart()
+        {
+            //Arrange
+            var sut = new Configure();
+
+            //Act
+            var dasState = sut.StateSelector();
+
+            // Assert
+            Assert.That(dasState.State, Is.EqualTo(State.ConfigureStart));
+        }
+    }
+}

DataPRO/StateMachine.Tests/States/DiagnoseShould.cs

@@ -0,0 +1,89 @@
+using DTS.DASLib.Service.StateMachine;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StateMachine.Tests
+{
+    [TestFixture]
+    public class DiagnoseShould
+    {
+        [Test]
+        public void State_ShouldBeRealtime()
+        {
+            //Arrange
+            var sut = new Realtime();
+
+            //Act & Assert
+            Assert.That(State.Realtime, Is.EqualTo(sut.State));
+        }
+
+        [Test]
+        public void StateSelector_ShouldReturnRealtime_WhenRequireAllUnitsPassDiagnosticIsFalse()
+        {
+            //Arrange
+            var sut = new Diagnose();
+            var status = sut.Status;
+            status.DiagnoseParams.ProceedToRealtimeWhenDone = true;
+            status.DiagnoseParams.RequireAllUnitsPassDiagnostic = false;
+
+            //Act
+            var dasState = sut.StateSelector();
+
+            // Assert
+            Assert.That(dasState.State, Is.EqualTo(State.RealtimeStart));
+        }
+
+        [Test]
+        public void StateSelector_ShouldReturnRealtime_WhenAllUnitsPassedDiagnostic()
+        {
+            //Arrange
+            var sut = new Diagnose();
+            var status = sut.Status;
+            status.DiagnoseParams.ProceedToRealtimeWhenDone = true;
+            status.DiagnoseParams.AllUnitsPassedDiagnostic = true;
+
+            //Act
+            var dasState = sut.StateSelector();
+
+            // Assert
+            Assert.That(dasState.State, Is.EqualTo(State.RealtimeStart));
+        }
+        [Test]
+        public void StateSelector_ShouldReturnDiagnose_ProceedToRealtimeWhenDoneIsFalse()
+        {
+            //Arrange
+            var sut = new Diagnose();
+            var status = sut.Status;
+            status.DiagnoseParams.ProceedToRealtimeWhenDone = false;
+            status.DiagnoseParams.AllUnitsPassedDiagnostic = true;
+            status.DiagnoseParams.RequireAllUnitsPassDiagnostic = false;
+
+            //Act
+            var dasState = sut.StateSelector();
+
+            // Assert
+            Assert.That(dasState.State, Is.EqualTo(State.Diagnose));
+        }
+
+        [Test]
+        public void StateSelector_ShouldReturnDiagnose_WhenAllUnitsPassedDiagnosticIsFalseAndRequireAllUnitsPassDiagnostic()
+        {
+            //Arrange
+            var sut = new Diagnose();
+            var status = sut.Status;
+            status.DiagnoseParams.ProceedToRealtimeWhenDone = true;
+            status.DiagnoseParams.RequireAllUnitsPassDiagnostic = true;
+            status.DiagnoseParams.AllUnitsPassedDiagnostic = false;
+
+            //Act
+            var dasState = sut.StateSelector();
+
+            // Assert
+            Assert.That(dasState.State, Is.EqualTo(State.Diagnose));
+        }
+    }
+}

DataPRO/StateMachine.Tests/States/HardwareDiscoveryStartShould.cs

@@ -0,0 +1,134 @@
+using DTS.DASLib.Service.StateMachine;
+using NSubstitute;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StateMachine.Tests
+{
+    [TestFixture]
+    class HardwareDiscoveryStartShould
+    {
+        [Test]
+        public void State_ShouldBeHardwareDiscoveryStart()
+        {
+            //Arrange
+            var sut = new HardwareDiscoveryStart();
+
+            //Act & Assert
+            Assert.That(State.HardwareDiscoveryStart, Is.EqualTo(sut.State));
+        }
+
+        [Test]
+        public void StateSelector_Should_ReturnConfigure()
+        {
+            //Arrange
+            var sut = new HardwareDiscoveryStart();
+            var status = sut.Status;
+            status.HardwareDiscoveryParams.ProceedWhenDone = true;
+
+            status.HardwareDiscoveryStatusInfo.AllDASFound = true;
+            status.HardwareDiscoveryParams.RequireAllDASFound = true;
+
+            //Act
+            var dasState = sut.StateSelector();
+
+            //Assert
+            Assert.That(dasState.State, Is.EqualTo(State.Configure));
+
+            //Arrange
+            status.HardwareDiscoveryParams.ProceedWhenDone = true;
+
+            status.HardwareDiscoveryStatusInfo.AllDASFound = true;
+            status.HardwareDiscoveryParams.RequireAllDASFound = false;
+
+            //Act
+            dasState = sut.StateSelector();
+
+            //Assert
+            Assert.That(dasState.State, Is.EqualTo(State.Configure));
+
+            //Arrange
+            status.HardwareDiscoveryParams.ProceedWhenDone = true;
+
+            status.HardwareDiscoveryStatusInfo.AllDASFound = false;
+            status.HardwareDiscoveryParams.RequireAllDASFound = false;
+
+            //Act
+            dasState = sut.StateSelector();
+
+            //Assert
+            Assert.That(dasState.State, Is.EqualTo(State.Configure));
+        }
+
+        [Test]
+        public void StateSelector_Should_ReturnDownload()
+        {
+            //Arrange
+            var sut = new HardwareDiscoveryStart();
+            var status = sut.Status;
+            status.HardwareDiscoveryParams.ProceedWhenDone = true;
+
+            status.HardwareDiscoveryStatusInfo.AllDASFound = true;
+            status.HardwareDiscoveryParams.RequireAllDASFound = true;
+
+            status.HardwareDiscoveryParams.GoToDownload = true;
+
+            //Act
+            var dasState = sut.StateSelector();
+            //Assert
+            Assert.That(dasState.State, Is.EqualTo(State.Download));
+        }
+
+        [Test]
+        public void StateSelector_Should_ReturnArm()
+        {
+            //Arrange
+            var sut = new HardwareDiscoveryStart();
+            var status = sut.Status;
+
+            status.HardwareDiscoveryParams.ProceedWhenDone = true;
+            //Cannot Configure
+            status.HardwareDiscoveryStatusInfo.AllDASFound = false;
+            status.HardwareDiscoveryParams.RequireAllDASFound = true;
+
+            //Cannot Download 
+            status.HardwareDiscoveryParams.GoToDownload = false;
+
+            //Can Arm
+            status.HardwareDiscoveryStatusInfo.SomeUnitsInArmState = true;
+
+            //Act
+            var dasState = sut.StateSelector();
+            // Assert
+            Assert.That(dasState.State, Is.EqualTo(State.Arm));
+        }
+
+        [Test]
+        public void StateSelector_Should_ReturnHardwareDiscovery()
+        {
+            //Arrange
+            var sut = new HardwareDiscoveryStart();
+            var status = sut.Status;
+
+            status.HardwareDiscoveryParams.ProceedWhenDone = true;
+            //Cannot Configure
+            status.HardwareDiscoveryStatusInfo.AllDASFound = false;
+            status.HardwareDiscoveryParams.RequireAllDASFound = true;
+
+            //Cannot Download 
+            status.HardwareDiscoveryParams.GoToDownload = false;
+
+            //Can Arm
+            status.HardwareDiscoveryStatusInfo.SomeUnitsInArmState = false;
+
+            //Act
+            var dasState = sut.StateSelector();
+            // Assert
+            Assert.That(dasState.State, Is.EqualTo(State.HardwareDiscovery));
+        }
+    }
+}

DataPRO/StateMachine.Tests/States/RealtimeShould.cs

@@ -0,0 +1,24 @@
+using DTS.DASLib.Service.StateMachine;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StateMachine.Tests
+{
+    [TestFixture]
+    public class RealtimeShould
+    {
+        [Test]
+        public void State_ShouldBeRealtime()
+        {
+            //Arrange
+            var sut = new Realtime();
+
+            //Act & Assert
+            Assert.That(State.Realtime, Is.EqualTo(sut.State));
+        }
+    }
+}

DataPRO/StateMachine.Tests/States/RealtimeStartShould.cs

@@ -0,0 +1,42 @@
+using DTS.DASLib.Service.StateMachine;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StateMachine.Tests
+{
+    [TestFixture]
+    public class RealtimeStartShould
+    {
+        [Test]
+        public void StateSelector_Should_ReturnRealtimeStart()
+        {
+            //Arrange
+            var sut = new RealtimeStart();
+            var status = sut.Status;
+            status.RealtimeStatus.CouldNotStartRealtime = true;
+
+            //Act
+            var dasState = sut.StateSelector();
+            // Assert
+            Assert.That(dasState.State, Is.EqualTo(State.RealtimeStart));
+        }
+
+        [Test]
+        public void StateSelector_Should_ReturnRealtime()
+        {
+            //Arrange
+            var sut = new RealtimeStart();
+            var status = sut.Status;
+            status.RealtimeStatus.CouldNotStartRealtime = false;
+
+            //Act
+            var dasState = sut.StateSelector();
+            // Assert
+            Assert.That(dasState.State, Is.EqualTo(State.Realtime));
+        }
+    }
+}

DataPRO/StateMachine.Tests/StatesShould.cs

@@ -0,0 +1,114 @@
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using DTS.DASLib.Service.StateMachine;
+using NSubstitute;
+using DTS.Common.Interface.DASFactory;
+
+namespace StateMachine.Tests
+{
+    [TestFixture]
+    public class StatesShould
+    {
+        [Test]
+        public void Instance_ShouldNotBeNull()
+        {
+            //Arrange
+            var sut = States.Instance;
+
+            //Act && Assert
+            Assert.That(sut, Is.Not.Null);
+        }
+
+        [Test]
+        public void Instance_ShouldBeSame()
+        {
+            //Arrange
+            var sut = States.Instance;
+
+            //Act && Assert
+            Assert.That(sut, Is.Not.Null.And.SameAs(States.Instance));
+        }
+
+        [Test]
+        public void States_ShouldReturnCorrectInstanceOfState()
+        {
+            //Arrange
+            var sut = States.Instance;
+
+            //Act && Assert
+            Assert.That(sut.Arm.State, Is.EqualTo(State.Arm));
+            Assert.That(sut.Arming.State, Is.EqualTo(State.Arming));
+            Assert.That(sut.Configure.State, Is.EqualTo(State.Configure));
+            Assert.That(sut.ConfigureStart.State, Is.EqualTo(State.ConfigureStart));
+            Assert.That(sut.Diagnose.State, Is.EqualTo(State.Diagnose));
+            Assert.That(sut.Download.State, Is.EqualTo(State.Download));
+            Assert.That(sut.HardwareDiscovery.State, Is.EqualTo(State.HardwareDiscovery));
+            Assert.That(sut.HardwareDiscoveryStart.State, Is.EqualTo(State.HardwareDiscoveryStart));
+            Assert.That(sut.Prepare.State, Is.EqualTo(State.Prepare));
+            Assert.That(sut.Realtime.State, Is.EqualTo(State.Realtime));
+            Assert.That(sut.RealtimeStart.State, Is.EqualTo(State.RealtimeStart));
+        }
+
+        [Test]
+        public void GetIDASState_ReturnAllKnownStates()
+        {
+            //Arrange
+            var sut = States.Instance;
+
+            //Act & Assert
+            var states = Enum.GetValues(typeof(State)).Cast<State>();
+            foreach (var state in states)
+            {
+                var dasState = sut.GetIDASState(state);
+                Assert.That(dasState.State, Is.EqualTo(state));
+            }
+        }
+
+        [Test]
+        public void GetIDASState_ShouldThrowException_WithUndefinedState()
+        {
+            //Arrange
+            var sut = States.Instance;
+            var enumVal = 45;
+
+            //Act & Assert
+            Assert.That(false, Is.EqualTo(Enum.IsDefined(typeof(State), enumVal)));
+            Assert.That(
+                () => sut.GetIDASState((State)enumVal)
+                , Throws.TypeOf<InvalidOperationException>()
+           .With
+           .Property("Message")
+           .EqualTo("Undefined State"));
+        }
+
+        [Test]
+        public void SetDASFactory_ShouldSetToAnInstanceOfDASFactory()
+        {
+            //Arrange
+            var sut = States.Instance;
+            var dasFactory = Substitute.For<IDASFactory>();
+            dasFactory.Language.Returns("En");
+
+            //Act
+            States.SetDASFactory(dasFactory);
+
+            //Assert
+            //Test thal all states have the defined DASFactory instance.
+            var states = Enum.GetValues(typeof(State)).Cast<State>();
+            foreach (var state in states)
+            {
+                //Depends on GetIDASState_ReturnAllKnownStates , If this test broken first fix GetIDASState_ReturnAllKnownStates
+                //Isolate the dependency to the GetIDASState_ReturnAllKnownStates test if it's possible
+                var dasState = sut.GetIDASState(state);
+                Assert.That(dasState.DASFactory, Is.Not.Null);
+                Assert.That(dasState.DASFactory.Language, Is.EqualTo("En"));
+            }
+
+
+        }
+    }
+}

DataPRO/StateMachine.Tests/StatusAndParameters/GlobalStatusInformationShould.cs

@@ -0,0 +1,438 @@
+using NUnit.Framework;
+using DTS.Common.Interface.DASFactory;
+using DTS.DASLib.Service;
+using DTS.DASLib.Service.StateMachine;
+using NSubstitute;
+using System.Collections.Generic;
+
+namespace StateMachine.Tests.StatusAndParameters
+{
+    [TestFixture]
+    class GlobalStatusInformationShould
+    {
+        GlobalStatusInformation sut;
+
+        [SetUp]
+        public void SetUp()
+        {
+            //Arrange
+            sut = new GlobalStatusInformation();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            sut = null;
+        }
+
+        [Test]
+        public void GetUnitsInRealtime_Should_ReturnNoUnites()
+        {
+            //Act
+            var result = sut.GetUnitsInRealtime();
+
+            //Assert
+            Assert.That(result, Is.EqualTo(new List<IDASCommunication>()));
+            Assert.That(result.Length, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void AddUnitInRealtime_Should_AddUnitCorrectly()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            //Act
+            sut.AddUnitInRealtime(device);
+
+            //Assert
+            Assert.That(sut.GetUnitsInRealtime().Length, Is.EqualTo(1));
+            Assert.That(sut.GetUnitsInRealtime()[0].SerialNumber, Is.EqualTo(sn));
+        }
+
+        [Test]
+        public void AddUnitInRealtime_Should_AddMultipleUnitsCorrectly()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            var secondDevice = Substitute.For<IDASCommunication>();
+            var secondSn = "SL60160";
+            secondDevice.SerialNumber.Returns(secondSn);
+
+            //Act
+            sut.AddUnitInRealtime(device);
+            sut.AddUnitInRealtime(secondDevice);
+
+            //Assert
+            Assert.That(sut.GetUnitsInRealtime().Length, Is.EqualTo(2));
+            Assert.That(sut.GetUnitsInRealtime()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsInRealtime()[1].SerialNumber, Is.EqualTo(secondSn));
+        }
+
+        [Test]
+        public void AddUnitInRealtime_ShouldNot_AddExistingDevice()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            var secondDevice = Substitute.For<IDASCommunication>();
+            var secondSn = "SL60160";
+            secondDevice.SerialNumber.Returns(secondSn);
+
+            var thirdDevice = secondDevice;
+
+            //Act
+            sut.AddUnitInRealtime(device);
+            sut.AddUnitInRealtime(secondDevice);
+            sut.AddUnitInRealtime(thirdDevice);
+
+            //Assert
+            Assert.That(sut.GetUnitsInRealtime().Length, Is.EqualTo(2));
+            Assert.That(sut.GetUnitsInRealtime()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsInRealtime()[1].SerialNumber, Is.EqualTo(secondSn));
+        }
+
+
+        [Test]
+        public void GetUnitsInArm_Should_ReturnNoUnites()
+        {
+            //Act
+            var result = sut.GetUnitsInArm();
+
+            //Assert
+            Assert.That(result, Is.EqualTo(new List<IDASCommunication>()));
+            Assert.That(result.Length, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void AddUnitInArm_Should_AddUnitCorrectly()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            //Act
+            sut.AddUnitInArm(device);
+
+            //Assert
+            Assert.That(sut.GetUnitsInArm().Length, Is.EqualTo(1));
+            Assert.That(sut.GetUnitsInArm()[0].SerialNumber, Is.EqualTo(sn));
+        }
+
+        [Test]
+        public void AddUnitInArm_Should_AddMultipleUnitsCorrectly()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            var secondDevice = Substitute.For<IDASCommunication>();
+            var secondSn = "SL60160";
+            secondDevice.SerialNumber.Returns(secondSn);
+
+            //Act
+            sut.AddUnitInArm(device);
+            sut.AddUnitInArm(secondDevice);
+
+            //Assert
+            Assert.That(sut.GetUnitsInArm().Length, Is.EqualTo(2));
+            Assert.That(sut.GetUnitsInArm()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsInArm()[1].SerialNumber, Is.EqualTo(secondSn));
+        }
+
+        [Test]
+        public void AddUnitInArm_ShouldNot_AddExistingDevice()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            var secondDevice = Substitute.For<IDASCommunication>();
+            var secondSn = "SL60160";
+            secondDevice.SerialNumber.Returns(secondSn);
+
+            var thirdDevice = secondDevice;
+
+            //Act
+            sut.AddUnitInArm(device);
+            sut.AddUnitInArm(secondDevice);
+            sut.AddUnitInArm(thirdDevice);
+
+            //Assert
+            Assert.That(sut.GetUnitsInArm().Length, Is.EqualTo(2));
+            Assert.That(sut.GetUnitsInArm()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsInArm()[1].SerialNumber, Is.EqualTo(secondSn));
+        }
+
+        [Test]
+        public void GetUnitsAtLowPower_Should_ReturnNoUnites()
+        {
+            //Act
+            var result = sut.GetUnitsAtLowPower();
+
+            //Assert
+            Assert.That(result, Is.EqualTo(new List<IDASCommunication>()));
+            Assert.That(result.Length, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void AddUnitAtLowPower_Should_AddUnitCorrectly()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            //Act
+            sut.AddUnitAtLowPower(device);
+
+            //Assert
+            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(1));
+            Assert.That(sut.GetUnitsAtLowPower()[0].SerialNumber, Is.EqualTo(sn));
+        }
+
+        [Test]
+        public void AddUnitAtLowPower_Should_AddMultipleUnitsCorrectly()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            var secondDevice = Substitute.For<IDASCommunication>();
+            var secondSn = "SL60160";
+            secondDevice.SerialNumber.Returns(secondSn);
+
+            //Act
+            sut.AddUnitAtLowPower(device);
+            sut.AddUnitAtLowPower(secondDevice);
+
+            //Assert
+            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(2));
+            Assert.That(sut.GetUnitsAtLowPower()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsAtLowPower()[1].SerialNumber, Is.EqualTo(secondSn));
+        }
+
+        [Test]
+        public void AddUnitAtLowPower_ShouldNot_AddExistingDevice()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            var secondDevice = Substitute.For<IDASCommunication>();
+            var secondSn = "SL60160";
+            secondDevice.SerialNumber.Returns(secondSn);
+
+            var thirdDevice = secondDevice;
+
+            //Act
+            sut.AddUnitAtLowPower(device);
+            sut.AddUnitAtLowPower(secondDevice);
+            sut.AddUnitAtLowPower(thirdDevice);
+
+            //Assert
+            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(2));
+            Assert.That(sut.GetUnitsAtLowPower()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsAtLowPower()[1].SerialNumber, Is.EqualTo(secondSn));
+        }
+
+        [Test]
+        public void AddUnitAtLowPower_Should_AddToLowPowerRemoveFromHighPower()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            var secondDevice = Substitute.For<IDASCommunication>();
+            var secondSn = "SL60160";
+            secondDevice.SerialNumber.Returns(secondSn);
+
+            var thirdDevice = Substitute.For<IDASCommunication>();
+            var thirdSn = "SL60161";
+            thirdDevice.SerialNumber.Returns(thirdSn);
+
+            //Act & Assert
+            sut.AddUnitAtLowPower(device);
+            sut.AddUnitAtLowPower(secondDevice);
+
+            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(2));
+            Assert.That(sut.GetUnitsAtLowPower()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsAtLowPower()[1].SerialNumber, Is.EqualTo(secondSn));
+
+            sut.AddUnitAtHighPower(thirdDevice);
+
+            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(1));
+            Assert.That(sut.GetUnitsAtHighPower()[0].SerialNumber, Is.EqualTo(thirdSn));
+
+            sut.AddUnitAtLowPower(thirdDevice);
+
+            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(3));
+            Assert.That(sut.GetUnitsAtLowPower()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsAtLowPower()[1].SerialNumber, Is.EqualTo(secondSn));
+            Assert.That(sut.GetUnitsAtLowPower()[2].SerialNumber, Is.EqualTo(thirdSn));
+
+            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void GetUnitsAtHighPower_Should_ReturnNoUnites()
+        {
+            //Act
+            var result = sut.GetUnitsAtHighPower();
+
+            //Assert
+            Assert.That(result, Is.EqualTo(new List<IDASCommunication>()));
+            Assert.That(result.Length, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void AddUnitAtHighPower_Should_AddUnitCorrectly()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            //Act
+            sut.AddUnitAtHighPower(device);
+
+            //Assert
+            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(1));
+            Assert.That(sut.GetUnitsAtHighPower()[0].SerialNumber, Is.EqualTo(sn));
+        }
+
+        [Test]
+        public void AddUnitAtHighPower_Should_AddMultipleUnitsCorrectly()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            var secondDevice = Substitute.For<IDASCommunication>();
+            var secondSn = "SL60160";
+            secondDevice.SerialNumber.Returns(secondSn);
+
+            //Act
+            sut.AddUnitAtHighPower(device);
+            sut.AddUnitAtHighPower(secondDevice);
+
+            //Assert
+            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(2));
+            Assert.That(sut.GetUnitsAtHighPower()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsAtHighPower()[1].SerialNumber, Is.EqualTo(secondSn));
+        }
+
+        [Test]
+        public void AddUnitAtHighPower_ShouldNot_AddExistingDevice()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            var secondDevice = Substitute.For<IDASCommunication>();
+            var secondSn = "SL60160";
+            secondDevice.SerialNumber.Returns(secondSn);
+
+            var thirdDevice = secondDevice;
+
+            //Act
+            sut.AddUnitAtHighPower(device);
+            sut.AddUnitAtHighPower(secondDevice);
+            sut.AddUnitAtHighPower(thirdDevice);
+
+            //Assert
+            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(2));
+            Assert.That(sut.GetUnitsAtHighPower()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsAtHighPower()[1].SerialNumber, Is.EqualTo(secondSn));
+        }
+
+
+        [Test]
+        public void AddUnitAtHighPower_Should_AddToLowPowerRemoveFromLowPower()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            var secondDevice = Substitute.For<IDASCommunication>();
+            var secondSn = "SL60160";
+            secondDevice.SerialNumber.Returns(secondSn);
+
+            var thirdDevice = Substitute.For<IDASCommunication>();
+            var thirdSn = "SL60161";
+            thirdDevice.SerialNumber.Returns(thirdSn);
+
+            //Act & Assert
+            sut.AddUnitAtHighPower(device);
+            sut.AddUnitAtHighPower(secondDevice);
+
+            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(2));
+            Assert.That(sut.GetUnitsAtHighPower()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsAtHighPower()[1].SerialNumber, Is.EqualTo(secondSn));
+
+            sut.AddUnitAtLowPower(thirdDevice);
+
+            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(1));
+            Assert.That(sut.GetUnitsAtLowPower()[0].SerialNumber, Is.EqualTo(thirdSn));
+
+            sut.AddUnitAtHighPower(thirdDevice);
+
+            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(3));
+            Assert.That(sut.GetUnitsAtHighPower()[0].SerialNumber, Is.EqualTo(sn));
+            Assert.That(sut.GetUnitsAtHighPower()[1].SerialNumber, Is.EqualTo(secondSn));
+            Assert.That(sut.GetUnitsAtHighPower()[2].SerialNumber, Is.EqualTo(thirdSn));
+
+            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(0));
+        }
+
+
+        [Test]
+        public void Reset_Should_ResetProperties()
+        {
+            //Arrange
+            var device = Substitute.For<IDASCommunication>();
+            var sn = "SL60159";
+            device.SerialNumber.Returns(sn);
+
+            var device2 = Substitute.For<IDASCommunication>();
+            var sn2 = "SL60160";
+            device2.SerialNumber.Returns(sn2);
+
+            sut.AddUnitAtLowPower(device);
+            sut.AddUnitInArm(device);
+            sut.AddUnitInRealtime(device);
+            sut.AddUnitAtHighPower(device2);
+            sut.ExcitationOn = true;
+
+            //Act & Assert
+            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(1));
+            Assert.That(sut.GetUnitsInArm().Length, Is.EqualTo(1));
+            Assert.That(sut.GetUnitsInRealtime().Length, Is.EqualTo(1));
+            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(1));
+            Assert.That(sut.ExcitationOn, Is.EqualTo(true));
+
+            sut.Reset();
+            Assert.That(sut.GetUnitsAtLowPower().Length, Is.EqualTo(0));
+            Assert.That(sut.GetUnitsInArm().Length, Is.EqualTo(0));
+            Assert.That(sut.GetUnitsInRealtime().Length, Is.EqualTo(0));
+            Assert.That(sut.GetUnitsAtHighPower().Length, Is.EqualTo(0));
+            Assert.That(sut.ExcitationOn, Is.EqualTo(false));
+        }
+    }
+}

DataPRO/StateMachine.Tests/StatusAndParameters/Realtime/RealtimeStatusInformationShould.cs

@@ -0,0 +1,87 @@
+using DTS.Common.Interface.DASFactory;
+using DTS.DASLib.Service;
+using DTS.DASLib.Service.StateMachine;
+using NSubstitute;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+
+
+namespace StateMachine.Tests.StatusAndParameters
+{
+    [TestFixture]
+    class RealtimeStatusInformationShould
+    {
+        [Test]
+        public void StartRealtime_Should_CouldNotStartRealtimeBeTrue()
+        {
+
+            //Arrange
+            var sut = new RealtimeStatusInformation();
+            var das = Substitute.For<IDASCommunication>();
+
+            var dasList = new List<IDASCommunication> { das };
+
+            var indices = new List<int>();
+            indices.Add(0);
+            var moduleIndices = indices;
+
+            var useSingleSampleMode = false;
+            var realtimeSampleRate = 1000;
+            var realtimeDelayBetweenPollsInMilliSecond = 4;
+            var allowMultipleSampleRealtime = true;
+
+
+            var b = new byte[1];
+            b[0] = 0;
+            var idasToActiveChannels = new Dictionary<IDASCommunication, byte[]>();
+            idasToActiveChannels.Add(dasList[0], b);
+
+
+            Action CompleteAction = () =>
+            {
+                Console.WriteLine("Realtime started");
+            };
+            Action<double, double> SetRealtimeSampleRateAAF = (p, q) =>
+            {
+                Console.WriteLine("Set RealtimeSampleRateAAF {0},{1}", p, q);
+            };
+
+            ServiceBase.Callback StartRealtimeCallback = (data) =>
+            {
+                if (data.Status == ServiceBase.CallbackData.CallbackStatus.AllFinished)
+                {
+                    Console.WriteLine("Finished receiving data");
+                }
+
+                if (data.Status == ServiceBase.CallbackData.CallbackStatus.NewData)
+                {
+
+                    Console.WriteLine("Receiving new data {0}", data.Data[0].SampleNumber.ToString());
+                }
+            };
+
+            //Act
+            sut.StartRealtime(dasList, moduleIndices, useSingleSampleMode, realtimeSampleRate,
+                realtimeDelayBetweenPollsInMilliSecond, allowMultipleSampleRealtime, SetRealtimeSampleRateAAF, CompleteAction,
+                idasToActiveChannels, StartRealtimeCallback);
+
+            //Assert
+            Assert.That(sut.CouldNotStartRealtime, Is.EqualTo(true));
+
+        }
+
+        [Test]
+        public void IsInRealtime_Should_ReturnFalse()
+        {
+            //Arrange
+            var sut = new RealtimeStatusInformation();
+
+            //Act
+            var result = sut.IsInRealtime;
+
+            //Assert 
+            Assert.That(result, Is.EqualTo(false));
+        }
+    }
+}

DataPRO/StateMachine.Tests/obj/Debug/.NETFramework,Version=v4.6.1.AssemblyAttributes.cs

@@ -0,0 +1,4 @@
+// <autogenerated />
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETFramework,Version=v4.6.1", FrameworkDisplayName = "")]

DataPRO/StateMachine.Tests/packages.config

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Castle.Core" version="4.4.0" targetFramework="net461" />
+  <package id="NSubstitute" version="4.2.1" targetFramework="net461" />
+  <package id="NUnit" version="3.12.0" targetFramework="net461" />
+  <package id="NUnit3TestAdapter" version="3.14.0" targetFramework="net461" />
+  <package id="System.Runtime.CompilerServices.Unsafe" version="4.5.2" targetFramework="net461" />
+  <package id="System.Threading.Tasks.Extensions" version="4.5.3" targetFramework="net461" />
+</packages>