Changes in MainSeq, Procedure, BenchControlPanel, TestProgressControls, etc.

Common/SerializableDictionary.cs

@@ -1,4 +1,7 @@
-using System;
+///
+/// Copyright (c) 2021 Sensus Slovensko a.s.
+///
+using System;
 using System.Collections.Generic;
 using System.Xml.Serialization;
 

Common/Utils.cs

@@ -1,4 +1,7 @@
-using System;
+///
+/// Copyright (c) 2021 Sensus Slovensko a.s.
+///
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -8,5 +11,11 @@ namespace Common
 {
     public class Utils
     {
+        public static string GetTestName(string name, int repeats, int repetitionNr)
+        {
+            if (name == null) return null;
+            if (repeats == 1) return name;
+            return string.Format("{0} ({1}/{2})", name, repetitionNr, repeats);
+        }
     }
 }

Config/Config.csproj

@@ -19,7 +19,7 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
     <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>TRACE;DEBUG;MUNICH</DefineConstants>
+    <DefineConstants>TRACE;DEBUG;TURA_IPERL_NEW;IPERL;ORACLE_DB;LANG_SK</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
@@ -30,7 +30,7 @@
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
     <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE;MUNICH</DefineConstants>
+    <DefineConstants>TRACE;TURA_IPERL_NEW;IPERL;ORACLE_DB;LANG_SK</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <Prefer32Bit>false</Prefer32Bit>
@@ -91,6 +91,7 @@
     <Compile Include="Entities\Profile.cs" />
     <Compile Include="Entities\PTest.cs" />
     <Compile Include="Entities\Test.cs" />
+    <Compile Include="Entities\TestInstance.cs" />
     <Compile Include="Entities\TransitionSequence.cs" />
     <Compile Include="Entities\TransitionStep.cs" />
     <Compile Include="Entities\Uncertainty.cs" />
@@ -141,6 +142,10 @@
     <EmbeddedResource Include="Resources\Strings.zh-CN.resx" />
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\Common\Common.csproj">
+      <Project>{c8939821-ba5c-4988-a3d0-bf53b74865c7}</Project>
+      <Name>Common</Name>
+    </ProjectReference>
     <ProjectReference Include="..\Users\Users.csproj">
       <Project>{6E5CB0E9-E1B6-4E5D-AC6E-B1049E180F2B}</Project>
       <Name>Users</Name>

Config/Entities/Procedure.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2020 Sensus Slovensko a.s.
+/// Copyright (c) 2013-2021 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
@@ -11,7 +11,7 @@ namespace Config.Entities
     /// <summary>
     /// Stores one test procedure, supports revisions and history log
     /// </summary>
-	public class Procedure : IHasName, IHasItemNr
+    public class Procedure : IHasName, IHasItemNr
     {
         public virtual int Id { get; protected set; }
 		public virtual int ItemNr { get; set; }
@@ -53,14 +53,13 @@ namespace Config.Entities
 		public virtual IList<ComponentProcedure> MoreParams { get; set; }
 		public virtual IList<Test> Tests { get; set; }
 
+        TestInstance[] testInstances;
+
         /// Wrapper
         public virtual IList<Test> RegularTests()
         {
             IList<Test> rslt = new List<Test>();
-            foreach (var t in Tests)
-            {
-                if ((t.Name.Length > 0 && t.Name[0] != '[') || !t.Name.Contains("]"))  rslt.Add(t);
-            }
+            foreach (var t in Tests) if (t.IsRegular()) rslt.Add(t);
             return rslt;
         }
 
@@ -70,6 +69,7 @@ namespace Config.Entities
         {
 			MoreParams = new List<ComponentProcedure>();
 			Tests = new List<Test>();
+            testInstances = null;
 
 			///
 			/// Default values
@@ -96,6 +96,70 @@ namespace Config.Entities
 			ItemNr = itemNr;
 		}
 
+        public virtual TestInstance[] UpdateTestInstances(IList<string> loopStartNames, IList<string> loopEndNames, IList<string> autoTests = null)
+        {
+            List<TestInstance> instances = new List<TestInstance>();
+
+            if (Tests != null)
+            {
+                int i = 0;
+                while (i < Tests.Count)
+                {
+                    if (!loopStartNames.Contains(Tests[i].Method) && !loopEndNames.Contains(Tests[i].Method))   /// Loop.End is ignored outside a loop
+                    {
+                        ///
+                        /// Outside a loop
+                        ///
+                        for (int j = 1; j <= Tests[i].Repeats; j++)
+                            if (Tests[i].BelongsTo(autoTests))
+                                instances.Add(new TestInstance(Tests[i], j));
+                    }
+                    else if (loopStartNames.Contains(Tests[i].Method))
+                    {
+                        ///
+                        /// Entering a loop
+                        ///
+                        int loopsCount = Tests[i].Repeats;
+                        List<Test> testsInsideLoop = new List<Test>();
+                        i++;
+
+                        while (i < Tests.Count && !loopEndNames.Contains(Tests[i].Method))
+                        {
+                            ///
+                            /// Inside a loop
+                            ///
+                            if (Tests[i].Repeats == loopsCount && !loopStartNames.Contains(Tests[i].Method))    /// Loop.Start is ignored inside a loop
+                            {
+                                if (Tests[i].BelongsTo(autoTests))
+                                    testsInsideLoop.Add(Tests[i]);
+                            }
+
+                            i++;
+                        }
+
+                        ///
+                        /// Append instances of tests inside the last loop to the list
+                        ///
+                        for (int j = 1; j <= loopsCount; j++)
+                        {
+                            foreach (var t in testsInsideLoop)
+                                instances.Add(new TestInstance(t, j));
+                        }
+                    }
+
+                    i++;
+                }
+            }
+
+            testInstances = instances.ToArray();
+            return testInstances;
+        }
+
+        public virtual TestInstance[] GetTestInstances()
+        {
+            return testInstances;
+        }
+
         public virtual Procedure Clone()
         {
             Procedure result = new Procedure();

Config/Entities/Test.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2019 Sensus Slovensko a.s.
+/// Copyright (c) 2013-2021 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
@@ -108,6 +108,22 @@ namespace Config.Entities
 			Procedure = procedure;
 		}
 
+        public virtual bool IsRegular()
+        {
+            /// Irregular / event triggered test names have form "[event] TestName"
+            return (Name.Length > 0 && Name[0] != '[') || !Name.Contains("]");
+        }
+
+        public virtual bool BelongsTo(IList<string> autoTests)
+        {
+            if (IsRegular()) return true;
+
+            if (autoTests == null) return false;
+
+            string action = Name.Substring(1, Name.IndexOf(']') - 1);
+            return autoTests.Contains(action);
+        }
+
         // Makes a new copy of this object (not just a reference)
         public virtual Test Clone()
         {

Config/Entities/TestInstance.cs

@@ -0,0 +1,32 @@
+///
+/// Copyright (c) 2021 Sensus Slovensko a.s.
+///
+using System;
+
+namespace Config.Entities
+{
+    public class TestInstance
+    {
+        public Test Test;
+        public int Repetition;
+
+        public string Name
+        {
+            get
+            {
+                return (Test != null) ? Common.Utils.GetTestName(Test.Name, Test.Repeats, Repetition) : string.Empty;
+            }
+        }
+
+        public TestInstance(Test test, int repetition)
+        {
+            Test = test;
+            Repetition = repetition;
+        }
+
+        public override string ToString()
+        {
+            return Name;
+        }
+    }
+}

Results/Results.csproj

@@ -19,7 +19,7 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
     <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>TRACE;DEBUG;MUNICH</DefineConstants>
+    <DefineConstants>TRACE;DEBUG;TURA_IPERL_NEW;IPERL;ORACLE_DB;LANG_SK</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <PlatformTarget>x86</PlatformTarget>
@@ -29,7 +29,7 @@
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
     <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE;MUNICH</DefineConstants>
+    <DefineConstants>TRACE;TURA_IPERL_NEW;IPERL;ORACLE_DB;LANG_SK</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <Prefer32Bit>false</Prefer32Bit>
@@ -195,6 +195,10 @@
     <Compile Include="WMeterRsltItemSpec.cs" />
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\Common\Common.csproj">
+      <Project>{c8939821-ba5c-4988-a3d0-bf53b74865c7}</Project>
+      <Name>Common</Name>
+    </ProjectReference>
     <ProjectReference Include="..\Config\Config.csproj">
       <Project>{743DF7DB-C7B6-42EB-986D-0F485E5588E4}</Project>
       <Name>Config</Name>

Results/Utils.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2016-2019 Sensus Slovensko a.s.
+/// Copyright (c) 2016-2021 Sensus Slovensko a.s.
 ///
 using System;
 using System.Text;
@@ -11,9 +11,7 @@ namespace Results
 	{
 		public static string GetTestName(string name, int repeats, int repetitionNr)
 		{
-            if (name == null) return null;
-			if (repeats == 1) return name;
-			return string.Format("{0} ({1}/{2})", name, repetitionNr, repeats);
+            return Common.Utils.GetTestName(name, repeats, repetitionNr);
 		}
 
 		

ResultsBrowser/ResultsBrowser.csproj

@@ -21,7 +21,7 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
     <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>TRACE;DEBUG;MUNICH</DefineConstants>
+    <DefineConstants>TRACE;DEBUG;TURA_IPERL_NEW;IPERL;ORACLE_DB;LANG_SK</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
@@ -32,7 +32,7 @@
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
     <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE;MUNICH</DefineConstants>
+    <DefineConstants>TRACE;TURA_IPERL_NEW;IPERL;ORACLE_DB;LANG_SK</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <Prefer32Bit>false</Prefer32Bit>

TBF/BenchControl/Sequences/MainSeq.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2020 Sensus Slovensko a.s.
+/// Copyright (c) 2013-2021 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
@@ -106,7 +106,6 @@ namespace TBF.BenchControl.Sequences
             Selection selection;
             string selectedTestName;
 
-#if !DEBUG
             Bridge.OnActivity(this, Strings.Starting_system);
             WaitForOkButton();
             SetValvesToDefaultState();
@@ -159,7 +158,6 @@ namespace TBF.BenchControl.Sequences
                 if (e.Contains(Event.UiCmdStop)) goto stop;
             }
             while (!e.Contains(Event.BalanceDone));
-#endif
 
         select_procedure:
 
@@ -701,29 +699,40 @@ namespace TBF.BenchControl.Sequences
 				IList<DeferredTestEvaluationData> deferredData = new List<DeferredTestEvaluationData>();
                 bool veryFirstTestInTheRestOfCycle = true;
 
-				int selsctedTestIx = simultWithPurgingCount;	/// Applies when  selection == Selection.Cycle
-				int repetNr = 1;
+                int selsctedTestIx = -1;    ///= undefined
 				///
-				if (selection == Selection.RestOfCycle)			/// ... otherwise
-				{
-                    Test slctdTest = TBF.BenchControl.StateMachine.Procedure.GetTest(selectedTestName, out selsctedTestIx, out repetNr);
-                    if (slctdTest == null || (selsctedTestIx < simultWithPurgingCount)
-                                          || (selsctedTestIx >= StateMachine.Tests.Count - simultWithEvacuationCount))
-					{
+                if (selection == Selection.RestOfCycle)			/// ... otherwise
+                {
+                    for (int i = 0; i < StateMachine.TestInstances.Length; i++)
+                    {
+                        if (selectedTestName == StateMachine.TestInstances[i].Name)
+                        {
+                            selsctedTestIx = i;
+                            break;
+                        }
+                    }
+
+                    if ((selsctedTestIx < simultWithPurgingCount) ||
+                        (selsctedTestIx >= StateMachine.TestInstances.Length - simultWithEvacuationCount))
+                    {
                         /// Invalid test selection
-						UiBridge.Bridge.OnError(this, string.Format("No test specified"));
-						goto select_cycle_or_test;
-					}
-				}
+                        UiBridge.Bridge.OnError(this, string.Format("No test specified"));
+                        goto select_cycle_or_test;
+                    }
+                }
+                else
+                {
+                    selsctedTestIx = simultWithPurgingCount;	    /// Applies when  selection == Selection.Cycle
+                }
 
 
                 float TimeEstimateTotal = 0;		/// Time estimate of the selected cycle or test
 
-				for (int i = selsctedTestIx; i < StateMachine.Tests.Count - simultWithEvacuationCount; i++)
+                for (int i = selsctedTestIx; i < StateMachine.TestInstances.Length - simultWithEvacuationCount; i++)
 				{
-					Test test = StateMachine.Tests[i];
+                    Test test = StateMachine.TestInstances[i].Test;
 
-					TimeEstimateTotal += (test.Repeats * (test.TstTime + 10.0f));
+					TimeEstimateTotal += (test.TstTime + 10.0f);
 
 					/// Try to fetch all test paths and transitions
 					/// to detect configuration errors as early as possible.
@@ -743,19 +752,16 @@ namespace TBF.BenchControl.Sequences
 				}
 
 				int currentTestIx = selsctedTestIx;
-				bool isOuterLoopMode = false;
-				int outerLoopStartIx = -1;			/// This is to identify program errors
-				int outerLoopRepeats = 0;
-				while (currentTestIx < StateMachine.Tests.Count - simultWithEvacuationCount)
+                while (currentTestIx < StateMachine.TestInstances.Length - simultWithEvacuationCount)
 				{
-                    Test nextTest = (currentTestIx + 1 < StateMachine.Tests.Count - simultWithEvacuationCount)
-                                  ? StateMachine.Tests[currentTestIx + 1]
-                                  : null;
+                    TestInstance nextTest = (currentTestIx + 1 < StateMachine.TestInstances.Length - simultWithEvacuationCount)
+                                          ? StateMachine.TestInstances[currentTestIx + 1]
+                                          : null;
 
                     Test nextHydroTest = null;
-                    for (int i = currentTestIx + 1; i < StateMachine.Tests.Count - simultWithEvacuationCount; i++)
+                    for (int i = currentTestIx + 1; i < StateMachine.TestInstances.Length - simultWithEvacuationCount; i++)
                     {
-                        Test tst = StateMachine.Tests[i];
+                        Test tst = StateMachine.TestInstances[i].Test;
                         if (tst != null)
                         {
                             ITestMethod tm = TbfComponents.FindComponent(tst.Method) as ITestMethod;
@@ -803,12 +809,10 @@ namespace TBF.BenchControl.Sequences
                     }
 
 					/// Fetch paths and transitions of this test
-                    Test test = StateMachine.Tests[currentTestIx];
-                    TBF.BenchControl.Generic.IComponent testMethodComp = TbfComponents.FindComponent(test.Method);
+                    TestInstance testInst = StateMachine.TestInstances[currentTestIx];
+                    TBF.BenchControl.Generic.IComponent testMethodComp = TbfComponents.FindComponent(testInst.Test.Method);
                     string errorMsg;
-                    if (!(testMethodComp is TBF.BenchControl.TestMethods.OuterLoop.Start.Component) &&
-						!(testMethodComp is TBF.BenchControl.TestMethods.OuterLoop.End.Component) &&
-						!StateMachine.GetPaths(test, (StateMachine.Procedure.MetersKind == MetersKind.HeatMeter),
+                    if (!StateMachine.GetPaths(testInst.Test, (StateMachine.Procedure.MetersKind == MetersKind.HeatMeter),
                                                out inPath, out benchPath, out outPath, out sensPath,
                                                out heatMetersPath,
                                                out transitionBefore, out transitionBetween, out transitionAfter,
@@ -830,12 +834,7 @@ namespace TBF.BenchControl.Sequences
 					ITestMethod testMethod = testMethodComp as ITestMethod;
 					if (testMethod != null && testMethod.CanTest(StateMachine.Procedure.MetersKind))
 					{
-                        if (isOuterLoopMode && (outerLoopRepeats != test.Repeats) && !(testMethod is TestMethods.OuterLoop.End.Component))
-                        {
-                            goto config_error;
-                        }
-
-                        StateMachine.LoadTestParams(test);
+                        StateMachine.LoadTestParams(testInst.Test);
 
                         if ((sensPath != null) && (sensPath.RegisterReaders != null))
                         {
@@ -866,119 +865,80 @@ namespace TBF.BenchControl.Sequences
                             int timeEstTransBetween = testMethod.DoTransitions() ? GetTransitionTimeEst(transitionBetween) : 1;
                             int timeEstTransAfter = testMethod.DoTransitions() ? GetTransitionTimeEst(transitionAfter) : 1;
 
-                            TestProgressEventArgs.SetEstimatedTimes(new int[] { 1, timeEstTransBefore, 1, 30, 0, Convert.ToInt32(test.TstTime) + 15, timeEstTransAfter, 0 });
-                            Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetNr, Config.Entities.Progress.JustStarted));
+                            TestProgressEventArgs.SetEstimatedTimes(new int[] { 1, timeEstTransBefore, 1, 30, 0, Convert.ToInt32(testInst.Test.TstTime) + 15, timeEstTransAfter, 0 });
+                            Bridge.OnTestProgress(this, new TestProgressEventArgs(testInst.Test, testInst.Repetition, Config.Entities.Progress.JustStarted));
 
                             bool currentTestFinished = true;
                             bool doOneMoreRepetition = false;
-                            do
+
+                            bool doExecuteTransitionBefore = (currentTestIx == simultWithPurgingCount) || (testInst.Test != StateMachine.TestInstances[currentTestIx - 1].Test) || veryFirstTestInTheRestOfCycle;
+                            bool isLastRepetition = (currentTestIx == StateMachine.TestInstances.Length - simultWithEvacuationCount - 1) || (testInst.Test != StateMachine.TestInstances[currentTestIx + 1].Test);
+                            veryFirstTestInTheRestOfCycle = false;
+                            if (testMethod.DoTransitions())
                             {
-                                bool doExecuteTransitionBefore = isOuterLoopMode || (repetNr == 1) || veryFirstTestInTheRestOfCycle;
-                                veryFirstTestInTheRestOfCycle = false;
-                                if (testMethod.DoTransitions())
-                                {
-                                    /// Make a transition before a test and before each test repetition
-                                    rsltTransBefore = Transition(doExecuteTransitionBefore ? transitionBefore : null, TransitionContext.BeforeTest);   /// Transition or SetRoute - start of test
-                                    log.InfoFormat("Test {0}: Transition({1}, BeforeTest) returned {2}", test.Name, (transitionBefore == null ? "null" : transitionBefore.Name), rsltTransBefore);
-                                }
-                                if (rsltTransBefore != Event.Done) break;
-
-                                log.InfoFormat("Test {0}: Execute(., {1}, {2})", test.Name, repetNr, isOuterLoopMode || repetNr == test.Repeats);
-                                e = testMethod.Execute(test, repetNr, isOuterLoopMode || repetNr == test.Repeats);
-
-                                if (e.Contains(Event.MakeSecondPass) && testMethod is ITestMethodWith2ndPass)
-                                {
-                                    deferredData.Add(new DeferredTestEvaluationData(test, repetNr, (testMethod as ITestMethodWith2ndPass).IntermediateData));
-                                }
-
-                                currentTestFinished = (rsltTransBefore == Event.Done && !e.Contains(Event.Error)
-                                                                                     && !e.Contains(Event.ConfigurationError)
-                                                                                     && !e.Contains(Event.OpArgumentError)
-                                                                                     && !e.Contains(Event.UiCmdStop));
-
-                                Bridge.OnTestProgress(this, new TestProgressEventArgs(test, repetNr, currentTestFinished ? Config.Entities.Progress.Completed
-                                                                                                                        : Config.Entities.Progress.Aborted));
-
-                                if (e.Contains(Event.OuterLoopStart)) break;	/// Do not repeat OuterLoopStart test in this loop
-                                if (currentTestFinished && !isOuterLoopMode) repetNr++;
-
-                                doOneMoreRepetition = currentTestFinished && !isOuterLoopMode && (repetNr <= test.Repeats);
-
-                                if (testMethod.DoTransitions() && doOneMoreRepetition)
-                                {
-                                    /// Make a transition between two test repetitions
-                                    rsltTransBetween = Transition(transitionBetween, TransitionContext.BetweenTests);   /// Transition or SetRoute - start of test
-                                    log.InfoFormat("Test {0}: Transition({1}, BetweenTests) returned {2}", test.Name, (transitionBetween == null ? "null" : transitionBetween.Name), rsltTransBetween);
-                                }
+                                /// Make a transition before a test and before each test repetition
+                                rsltTransBefore = Transition(doExecuteTransitionBefore ? transitionBefore : null, TransitionContext.BeforeTest);   /// Transition or SetRoute - start of test
+                                log.InfoFormat("Test {0}: Transition({1}, BeforeTest) returned {2}", testInst.Name, (transitionBefore == null ? "null" : transitionBefore.Name), rsltTransBefore);
                             }
-                            while ((rsltTransBetween == Event.Done) && doOneMoreRepetition);
+                            if (rsltTransBefore != Event.Done) break;
 
-                            if (currentTestFinished && !isOuterLoopMode && repetNr > test.Repeats) repetNr = 1;  /// Reset repetNr
+                            log.InfoFormat("Test {0}: Execute(., {1}, {2})", testInst.Name, testInst.Repetition, isLastRepetition);
+                            e = testMethod.Execute(testInst.Test, testInst.Repetition, isLastRepetition);
+
+                            if (e.Contains(Event.MakeSecondPass) && testMethod is ITestMethodWith2ndPass)
+                            {
+                                deferredData.Add(new DeferredTestEvaluationData(testInst.Test, testInst.Repetition, (testMethod as ITestMethodWith2ndPass).IntermediateData));
+                            }
+
+                            currentTestFinished = (rsltTransBefore == Event.Done && !e.Contains(Event.Error)
+                                                                                 && !e.Contains(Event.ConfigurationError)
+                                                                                 && !e.Contains(Event.OpArgumentError)
+                                                                                 && !e.Contains(Event.UiCmdStop));
+
+                            Bridge.OnTestProgress(this, new TestProgressEventArgs(testInst.Test, testInst.Repetition, currentTestFinished ? Config.Entities.Progress.Completed
+                                                                                                                                          : Config.Entities.Progress.Aborted));
 
                             if (testMethod.DoTransitions() && !e.Contains(Event.RecoverableError))
                             {
-                                /// Make a transition after the last test repetition
-                                TransitionContext endContext =
-                                    !currentTestFinished ? TransitionContext.Stop
-                                                         : ((nextTransitionBefore != null) && (nextTransitionBefore.Name.ToLower().Contains("fastflow"))) ? TransitionContext.AfterTestWithOverlap
-                                                                                                                                                         : TransitionContext.AfterTest;
-                                rsltTransAfter = Transition(transitionAfter, endContext);   /// Transition or SetRoute - end of test
-                                log.InfoFormat("Test {0}: Transition({1}, {2}) returned {3}", test.Name, (transitionAfter == null ? "null" : transitionAfter.Name), endContext, rsltTransAfter);
+                                if (currentTestFinished && !isLastRepetition)
+                                {
+                                    /// Make a transition between two test repetitions
+                                    rsltTransBetween = Transition(transitionBetween, TransitionContext.BetweenTests);   /// Transition or SetRoute - start of test
+                                    log.InfoFormat("Test {0}: Transition({1}, BetweenTests) returned {2}", testInst.Name, (transitionBetween == null ? "null" : transitionBetween.Name), rsltTransBetween);
+                                }
+                                else
+                                {
+                                    /// Make a transition after the last test repetition
+                                    TransitionContext endContext =
+                                        !currentTestFinished ? TransitionContext.Stop
+                                                             : ((nextTransitionBefore != null) && (nextTransitionBefore.Name.ToLower().Contains("fastflow"))) ? TransitionContext.AfterTestWithOverlap
+                                                                                                                                                             : TransitionContext.AfterTest;
+                                    rsltTransAfter = Transition(transitionAfter, endContext);   /// Transition or SetRoute - end of test
+                                    log.InfoFormat("Test {0}: Transition({1}, {2}) returned {3}", testInst.Name, (transitionAfter == null ? "null" : transitionAfter.Name), endContext, rsltTransAfter);
+                                }
                             }
                         }
 
                         if (rsltTransBefore == Event.Error || rsltTransBetween == Event.Error|| e.Contains(Event.Error))
                         {
-                            isOuterLoopMode = false;
                             goto error;
                         }
                         else if (e.Contains(Event.ConfigurationError))
 						{
-							isOuterLoopMode = false;
                             goto select_cycle_or_test;  /// OR goto config_error;  ???
 						}
 						else if (e.Contains(Event.OpArgumentError))
 						{
-							isOuterLoopMode = false;
 							goto config_error;
 						}
                         else if (rsltTransBefore == Event.UiCmdStop || e.Contains(Event.UiCmdStop) || e.Contains(Event.RecoverableError))
 						{
-							isOuterLoopMode = false;
 							goto stop_within_cycle;
 						}
-						else if (e.Contains(Event.OuterLoopStart))
-						{
-							if (isOuterLoopMode)
-							{
-								goto config_error;
-							}
-
-							isOuterLoopMode = true;
-                            outerLoopRepeats = (nextTest != null) ? nextTest.Repeats : 1;
-							repetNr = 1;
-							outerLoopStartIx = currentTestIx;
-						}
-						else if (e.Contains(Event.OuterLoopEnd))
-						{
-                            if (!isOuterLoopMode)
-                            {
-                                goto config_error;
-                            }
-                            else if (++repetNr <= outerLoopRepeats)
-                            {
-                                currentTestIx = outerLoopStartIx;
-                            }
-                            else
-                            {
-							    isOuterLoopMode = false;
-							    repetNr = 1;        /// Reset repetNr
-                            }
-                        }
 					}
 					else
 					{
-						UiBridge.Bridge.OnError(this, string.Format(Strings.Method_0_cannot_be_used, test.Method));
+						UiBridge.Bridge.OnError(this, string.Format(Strings.Method_0_cannot_be_used, testInst.Test.Method));
 						goto select_cycle_or_test;
 					}
 
@@ -1035,15 +995,27 @@ namespace TBF.BenchControl.Sequences
                 /// selection == Selection.Test or Selection.Q1 or Selection.Q2 or Selection.Q3
                 /// Single test will be executed
 
-                int repetNr;
-                int testIx;
-				Test test = TBF.BenchControl.StateMachine.Procedure.GetTest(selectedTestName, out testIx, out repetNr);
-                if (test == null)
+                int testIx = -1;    ///= undefined
+                ///
+                for (int i = 0; i < StateMachine.TestInstances.Length; i++)
                 {
+                    if (selectedTestName == StateMachine.TestInstances[i].Name)
+                    {
+                        testIx = i;
+                        break;
+                    }
+                }
+
+                if (testIx < 0)
+                {
+                    /// Invalid test selection
                     UiBridge.Bridge.OnError(this, string.Format("No test specified"));
                     goto select_cycle_or_test;
                 }
 
+                Test test = StateMachine.TestInstances[testIx].Test;
+                int repetNr = StateMachine.TestInstances[testIx].Repetition;
+
                 /// Fetch the test paths and transitions
                 string errorMsg;
 				TBF.BenchControl.Generic.IComponent testMethodComp = TbfComponents.FindComponent(test.Method);

TBF/BenchControl/Sequences/MainSeqUtils.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2020 Sensus Slovensko a.s.
+/// Copyright (c) 2020-2021 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
@@ -704,15 +704,15 @@ namespace TBF.BenchControl.Sequences
             simultWithPurgingTests.Clear();
             simultWithPurgingParams.Clear();
             ///
-            foreach (var test in StateMachine.Tests)
+            foreach (var ti in StateMachine.TestInstances)
             {
-                Generic.IComponent testMethodComp = TbfComponents.FindComponent(test.Method);
+                Generic.IComponent testMethodComp = TbfComponents.FindComponent(ti.Test.Method);
                 if (testMethodComp == null) break;
 
-                testMethodComp.Cfg.LoadTestParamsFromDB(test);
+                testMethodComp.Cfg.LoadTestParamsFromDB(ti.Test);
 
                 ISimultTestMethod simultTest = testMethodComp as ISimultTestMethod;
-                MetersPath sensPath = StateMachine.GetMetersPath(test);
+                MetersPath sensPath = StateMachine.GetMetersPath(ti.Test);
 
                 if (simultTest == null || !simultTest.SimultWithPrevious || sensPath == null) break;
 
@@ -725,7 +725,7 @@ namespace TBF.BenchControl.Sequences
                     break;
                 }
 
-                simultWithPurgingTests.Add(test);
+                simultWithPurgingTests.Add(ti.Test);
                 simultWithPurgingParams.Add(testMethodComp.Cfg.GetRuntimeTestParamsProvider().Clone() as Generic.ITestParams);
                 simultWithPurgingCount++;
             }
@@ -738,9 +738,9 @@ namespace TBF.BenchControl.Sequences
             simultWithEvacuationTests.Clear();
             simultWithEvacuationParams.Clear();
             ///
-            for (int i = StateMachine.Tests.Count - 1; i >= simultWithPurgingCount; i--)
+            for (int i = StateMachine.TestInstances.Length - 1; i >= simultWithPurgingCount; i--)
             {
-                var test = StateMachine.Tests[i];
+                var test = StateMachine.TestInstances[i].Test;
 
                 Generic.IComponent testMethodComp = TbfComponents.FindComponent(test.Method);
                 if (testMethodComp == null) break;

TBF/BenchControl/Sequences/SequenceBase.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Metering Systems
+/// Copyright (c) 2013-2021 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
@@ -1721,7 +1721,7 @@ namespace TBF.BenchControl.Sequences
         /// <returns>Test result</returns>
         protected void MakeSimulatedHeatMeters(Config.Entities.Test test, int repetitionNr, int part, float errorPct, double energy, float energyErrLimLo, float energyErrLimHi, bool evaluateVolume)
         {
-            string fullTestName = Results.Utils.GetTestName(test.Name, test.Repeats, repetitionNr);
+            string fullTestName = Common.Utils.GetTestName(test.Name, test.Repeats, repetitionNr);
 
             Results.Entities.TestRslt tstRslt = ProcessData.BatchRslts.GetTestRslt(fullTestName, part);
 

TBF/BenchControl/StateMachine.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2019 Sensus Slovensko a.s.
+/// Copyright (c) 2013-2021 Sensus Slovensko a.s.
 ///
 using System;
 using System.Text;
@@ -65,6 +65,8 @@ namespace TBF.BenchControl
 		public static IList<IValve> CoupledValves;				/// list of coupled valves
 		public static IList<Elde.ValveEx.Valve> ExtendedValves;	/// list of extended valves
 
+        public static IList<string> LoopStartNames;
+        public static IList<string> LoopEndNames;
 
         /// Time and synchronization
 #if TURA_IPERL || TURA_IPERL_NEW
@@ -112,8 +114,8 @@ namespace TBF.BenchControl
 		/// <summary>
 		/// Loaded by LoadProcedure() or IOperation LoadProcedureOp(...)
 		/// </summary>
-		public static Procedure Procedure;					/// Procedure
-		public static IList<Test> Tests;					/// Tests
+		public static Procedure Procedure;				/// Procedure
+        public static TestInstance[] TestInstances;		/// Tests
         public static bool IsRemoteProcedure;                                                            
 
 
@@ -226,6 +228,8 @@ namespace TBF.BenchControl
             SequenceBase.PumpsWithFM = new List<IPumpFM>();
 			SequenceBase.WaterMeters = new List<IWaterMeter>();
 			SequenceBase.Cameras = new List<ICamera>();
+            LoopStartNames = new List<string>();
+            LoopEndNames = new List<string>();
             UInt128 valvesToInvert = 0;
 			foreach (var cmpnt in components)
 			{
@@ -261,6 +265,9 @@ namespace TBF.BenchControl
                     BenchErrorOp = (cmpnt as GenericDevices.IParallelOutput).ShowBenchErrorOp();
                 }
 
+                if (cmpnt is ITestMethod && cmpnt.ClassName == "TestMethods.OuterLoop.Start") LoopStartNames.Add(cmpnt.Name);
+                if (cmpnt is ITestMethod && cmpnt.ClassName == "TestMethods.OuterLoop.End") LoopEndNames.Add(cmpnt.Name);
+
 				if (cmpnt is IScaleOrTank)
 				{
 					IScaleOrTank tank = cmpnt as IScaleOrTank;
@@ -562,28 +569,13 @@ namespace TBF.BenchControl
             {
                 IsRemoteProcedure = isRemote;
                 Procedure = selectedProcs[0];
-
-                Tests = selectedProcs[0].Tests;
-                for (int i = Tests.Count - 1; i >= 0; i--)
-                {
-                    Test test = Tests[i];
-                    if ((test.Name.Length > 0) && (test.Name[0] == '[') && test.Name.Contains("]"))
-                    {
-                        /// This is an AutoAction test => If 'actionName' is not on 'autoTests' list the test should be removed
-                        int actionNameEndPos = test.Name.IndexOf(']');
-                        string actionName = test.Name.Substring(1, actionNameEndPos - 1);
-                        if (autoTests == null || autoTests.Count == 0 || !autoTests.Contains(actionName))
-                        {
-                            /// AutoAction test was not selected and should be deleted
-                            Tests.RemoveAt(i);
-                        }
-                    }
-                }
-
+                TestInstances = selectedProcs[0].UpdateTestInstances(LoopStartNames, LoopEndNames, autoTests);
                 return true;
             }
-
-            return false;
+            else
+            {
+                return false;
+            }
         }
 
 		public static void LoadProcedureParams(Procedure procedure)

TBF/BenchControl/TestMethods/FlyingStartMassCollProlonged/FlyingStartMassCollProlongedSeq.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2018-2020 Sensus Slovensko a.s.
+/// Copyright (c) 2018-2021 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
@@ -826,11 +826,12 @@ namespace TBF.BenchControl.TestMethods.FlyingStartMassCollProlonged
                     tstRslt.VolumeCTV *= tstRslt.TestTime + tstRslt.TestTimeCorrection;
                     tstRslt.VolumeCTV /= tstRslt.TestTime;
                 }
-                tstRslt.ConstMasterRaw = outPath.FlowMeter.LtrPerPulse;                                                                /// Uncorrected master flowmeter coefficient
-                tstRslt.ConstMasterCorr = outPath.FlowMeter.LtrPerPulseCorrected(flow, rangeIx);                          /// Corrected master pulses per liter
-                tstRslt.ConstMaster     = (massPulses == 0) ? tstRslt.ConstMasterCorr : (tstRslt.VolumeCTV / massPulses);
-                tstRslt.VolumeMaster    = LtrPerRefPulse * massPulses;						                                            /// [l] volume from the master flow meter
-                tstRslt.ErrorMaster     = Formulas.ErrorFromVolumes(tstRslt.VolumeMaster, tstRslt.VolumeCTV);
+                tstRslt.VolumeMaster    = LtrPerRefPulse * massPulses;						            /// [l] volume from the master flow meter                             /// [l] volume from the master flow meter
+                tstRslt.ConstMasterRaw  = outPath.FlowMeter.LtrPerPulse;                                /// Uncorrected master flowmeter coefficient                             /// Uncorrected master flowmeter coefficient
+                tstRslt.ConstMasterCorr = outPath.FlowMeter.LtrPerPulseCorrected(flow, rangeIx);        /// Master pulses per liter from a correction table and a flow               /// Corrected master pulses per liter
+                tstRslt.ConstMaster     = (massPulses != 0) ? (tstRslt.VolumeCTV / massPulses) : tstRslt.ConstMasterCorr;
+                                                                                                        /// Master pulses per liter from the measured mass
+                tstRslt.ErrorMaster = Formulas.ErrorFromVolumes(tstRslt.VolumeMaster, tstRslt.VolumeCTV);
 
                 tstRslt.FlowVolume = 3.6 * totalPulses * tstRslt.VolumeCTV / (massPulses * tstRslt.TestTime);
                 tstRslt.FlowMean   = Convert.ToSingle(RefFlowStat.Average);
@@ -1006,10 +1007,12 @@ namespace TBF.BenchControl.TestMethods.FlyingStartMassCollProlonged
                             meterRslt.PulsesPerLiter = regReader.PulsesPerLtr;
 							meterRslt.PulsesMeter = Convert.ToDouble(regReader.WMPulses);
 
+                            log.DebugFormat("Water meter {0}: pulses/liter={1}, meter pulses={2}", i + 1, meterRslt.PulsesPerLiter, meterRslt.PulsesMeter);
+
 							if (dstrReader != null)
 							{
 								meterRslt.TimestampStart = dstrReader.TimestampSecStart;
-								meterRslt.TimestampEnd 	 = dstrReader.NoSamples ? (dstrReader.TimestampSecStart + tstRslt.TestTime) : dstrReader.TimestampSecEnd;
+								meterRslt.TimestampEnd 	 = !dstrReader.NoSamples ? dstrReader.TimestampSecEnd : (dstrReader.TimestampSecStart + tstRslt.TestTime);
 								meterRslt.TestTime 		 = meterRslt.TimestampEnd - meterRslt.TimestampStart;
 								meterRslt.VolumeStart 	 = dstrReader.VolumeLtrStart;        /// liter
 								meterRslt.VolumeEnd 	 = dstrReader.VolumeLtrEnd;          /// liter
@@ -1029,29 +1032,57 @@ namespace TBF.BenchControl.TestMethods.FlyingStartMassCollProlonged
                                     iPerl.LastTestResult2 = iPerl.LastTestResult;							/// Save shift previous test result
                                     iPerl.LastTestResult = meterRslt;										/// Save this test result
                                 }
-							}
+
+                                log.DebugFormat("Datastream: Tst={0} Tend={1} Tmtr={2} Ttime={3} Vst={4} Vend={5} Vmtr={6} Vref={7}",
+                                                 meterRslt.TimestampStart,
+                                                 meterRslt.TimestampEnd,
+                                                 meterRslt.TestTime,
+                                                 tstRslt.TestTime,
+                                                 meterRslt.VolumeStart,
+                                                 meterRslt.VolumeEnd,
+                                                 meterRslt.VolumeMeter,
+                                                 meterRslt.VolumeRef);
+                            }
 							else if (cameraRoi != null)
 							{
-								meterRslt.TimestampStart = cameraRoi.TimestampStart;					    /// second
-								meterRslt.TimestampEnd = cameraRoi.TimestampEnd;						    /// second
-								meterRslt.TestTime = cameraRoi.TimestampEnd - cameraRoi.TimestampStart;	    /// second
+								meterRslt.TimestampStart = cameraRoi.TimestampStart;					        /// [s]
+								meterRslt.TimestampEnd   = cameraRoi.TimestampEnd;						        /// [s]
+								meterRslt.TestTime       = cameraRoi.TimestampEnd - cameraRoi.TimestampStart;	/// [s]
 
-								meterRslt.VolumeStart = cameraRoi.VolumeStart;							    /// liter
-								meterRslt.VolumeEnd = cameraRoi.VolumeEnd;								    /// liter
-								meterRslt.VolumeMeter = cameraRoi.VolumeEnd - cameraRoi.VolumeStart;	    /// liter
+                                meterRslt.VolumeStart    = cameraRoi.VolumeStart;							    /// [l]
+                                meterRslt.VolumeEnd      = cameraRoi.VolumeEnd;								    /// [l]
+                                meterRslt.VolumeMeter    = cameraRoi.VolumeEnd - cameraRoi.VolumeStart;	        /// [l]
  
-								meterRslt.VolumeRef = tstRslt.VolumeCTV * meterRslt.TestTime * totalPulses / (tstRslt.TestTime * massPulses);
-                                meterRslt.PulsesMaster = totalPulses * meterRslt.TestTime / tstRslt.TestTime;
+								meterRslt.VolumeRef      = tstRslt.VolumeCTV * meterRslt.TestTime * totalPulses / (tstRslt.TestTime * massPulses);
+                                meterRslt.PulsesMaster   = totalPulses * meterRslt.TestTime / tstRslt.TestTime;
+
+                                log.DebugFormat("Camera: Tst={0} Tend={1} Tmtr={2} Ttime={3} Vst={4} Vend={5} Vmtr={6} Vref={7}",
+                                                 meterRslt.TimestampStart,
+                                                 meterRslt.TimestampEnd,
+                                                 meterRslt.TestTime,
+                                                 tstRslt.TestTime,
+                                                 meterRslt.VolumeStart,
+                                                 meterRslt.VolumeEnd,
+                                                 meterRslt.VolumeMeter,
+                                                 meterRslt.VolumeRef);
                             }
 							else
 							{
-                                meterRslt.TestTime     = cBrd.ImpulseTime(i + 1);						    /// TODO: Malo by sa citat z dosky
                                 meterRslt.PulsesMaster = Convert.ToDouble(regReader.WMRefPulses);
-                                meterRslt.VolumeStart  = 0;												    /// liter
-								meterRslt.VolumeEnd    = 0;												    /// liter
-								meterRslt.VolumeMeter  = meterRslt.PulsesMeter * regReader.LtrsPerPulse;	/// liter
-                                meterRslt.VolumeRef    = totalPulses * tstRslt.ConstMaster;	                /// liter
-							}
+                                meterRslt.TestTime     = cBrd.ImpulseTime(i + 1);						    /// [s]
+                                meterRslt.VolumeStart  = 0;												    /// [l]
+                                meterRslt.VolumeEnd    = 0;												    /// [l]
+                                meterRslt.VolumeMeter  = meterRslt.PulsesMeter * regReader.LtrsPerPulse;	/// [l]
+                                meterRslt.VolumeRef    = meterRslt.PulsesMaster * tstRslt.ConstMaster;	    /// [l], tstRslt.ConstMaster is calculated from massPulses and VolumeCTV (from scale)
+
+                                log.DebugFormat("Datastream:  RefPls4mtrRR={0} RefPls4mtrBrd={1} Tmtr={2} Ttime={3} Vmtr={4} Vref={5}",
+                                                 meterRslt.PulsesMaster,
+                                                 cBrd.EtPulses(i + 1),
+                                                 meterRslt.TestTime,
+                                                 tstRslt.TestTime,
+                                                 meterRslt.VolumeMeter,
+                                                 meterRslt.VolumeRef);
+                            }
 
                             meterRslt.Error = Formulas.ErrorFromVolumes(meterRslt.VolumeMeter, meterRslt.VolumeRef);
                             meterRslt.Passed = (meterRslt.Error >= test.GetErrLimLo(tstRslt.VolumeCTV, tstRslt.TestTime) + test.Uncertainty)

TBF/BenchControl/TestMethods/iPerlCommunication/iPerlCommunicationForm.cs

@@ -2684,9 +2684,9 @@ namespace TBF.BenchControl.TestMethods.iPerlCommunication
 			DateTime endTime = DateTime.Now;
 			int testTime = StateMachine.Time - startTimeSec;
 
-			if (!tests.Contains(StateMachine.Tests[0]))
+			if (!tests.Contains(StateMachine.TestInstances[0].Test))
 			{
-				tests.Insert(0, StateMachine.Tests[0]);	/// Add RFID test as the 1st item
+                tests.Insert(0, StateMachine.TestInstances[0].Test);	/// Add RFID test as the 1st item
 			}
 
 			foreach (var test in tests)

TBF/Properties/AssemblyInfo.cs

@@ -29,5 +29,5 @@ using System.Runtime.InteropServices;
 //      Build Number
 //      Revision
 //
-[assembly: AssemblyVersion("2.26.1551.0")]
-[assembly: AssemblyFileVersion("2.26.1551.0")]
+[assembly: AssemblyVersion("2.26.1582.0")]
+[assembly: AssemblyFileVersion("2.26.1582.0")]

TBF/TBF.csproj

@@ -39,7 +39,7 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
     <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>TRACE;DEBUG;MUNICH;CAMERA</DefineConstants>
+    <DefineConstants>TRACE;DEBUG;TURA_IPERL_NEW;IPERL;ORACLE_DB;LANG_SK;STABLE_MASS_EXTRAS</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
@@ -50,7 +50,7 @@
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
     <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE;MUNICH;CAMERA</DefineConstants>
+    <DefineConstants>TRACE;TURA_IPERL_NEW;IPERL;ORACLE_DB;LANG_SK;STABLE_MASS_EXTRAS</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <PlatformTarget>x86</PlatformTarget>
@@ -60,7 +60,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
     <DebugSymbols>true</DebugSymbols>
     <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>TRACE;DEBUG;MUNICH;CAMERA</DefineConstants>
+    <DefineConstants>TRACE;DEBUG;TURA_IPERL_NEW;IPERL;ORACLE_DB;LANG_SK;STABLE_MASS_EXTRAS</DefineConstants>
     <DebugType>full</DebugType>
     <PlatformTarget>x86</PlatformTarget>
     <ErrorReport>prompt</ErrorReport>
@@ -70,7 +70,7 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
     <OutputPath>bin\x86\Release\</OutputPath>
-    <DefineConstants>TRACE;MUNICH;CAMERA</DefineConstants>
+    <DefineConstants>TRACE;TURA_IPERL_NEW;IPERL;ORACLE_DB;LANG_SK;STABLE_MASS_EXTRAS</DefineConstants>
     <Optimize>true</Optimize>
     <DebugType>pdbonly</DebugType>
     <PlatformTarget>x86</PlatformTarget>
@@ -101,8 +101,9 @@
     <SignManifests>false</SignManifests>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="ControlComponent3Munich">
-      <HintPath>..\packages\ControlBoard\Munich\ControlComponent3Munich.dll</HintPath>
+    <Reference Include="ControlComponent3U, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\ControlBoard\iPerlST-new\ControlComponent3U.dll</HintPath>
     </Reference>
     <Reference Include="FluentNHibernate">
       <HintPath>..\packages\FluentNHibernate.2.0.3.0\lib\net40\FluentNHibernate.dll</HintPath>
@@ -3534,6 +3535,24 @@
     <None Include="Resources\RoiStyle1.bmp" />
     <None Include="Resources\RoiStyle2.bmp" />
     <None Include="Resources\RoiStyle3.bmp" />
+    <Content Include="libgcc_s_dw2-1.dll">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
+    <Content Include="libRfid1.dll">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
+    <Content Include="libRfid2.dll">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
+    <Content Include="libRfid3.dll">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
+    <Content Include="libRfid4.dll">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
+    <Content Include="libstdc++-6.dll">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </Content>
     <Content Include="Pictures\forward_dir_left.jpg">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </Content>

TBF/UI/MainWnd.Designer.cs

@@ -54,9 +54,9 @@ namespace TBF.UI
             this.horizontalSplitContainer = new System.Windows.Forms.SplitContainer();
             this.mainTabControl = new System.Windows.Forms.TabControl();
             this.homeTabPage = new System.Windows.Forms.TabPage();
-            this.ctrlBrdComponent = new ControlComponent3Munich.UserControl1();
+			this.ctrlBrdComponent = new ControlComponent_Torino2015.UserControl1();
             this.processTabPage = new System.Windows.Forms.TabPage();
-            this.processTabPageCtrl = new TBF.UI.Process.ProcessTabPageCtrl6();
+			this.processTabPageCtrl = new TBF.UI.Process.ProcessTabPageCtrl48();
             this.insertTabPage = new System.Windows.Forms.TabPage();
             this.resultsTabPage = new System.Windows.Forms.TabPage();
             this.resultsTabPageCtrl = new TBF.UI.ResultsMI.ResultsTabPageCtrl();

TBF/UI/Procedures/TestWizard/OracleWZTypSelection.cs

@@ -196,7 +196,7 @@ namespace TBF.UI.Procedures.TestWizard
             {
                 if (t.Publish != (byte)Config.Entities.Publish.Never &&
                     t.Publish != (byte)Config.Entities.Publish.Internal &&
-                    ((t.Name.Length > 0 && t.Name[0] != '[') || !t.Name.Contains("]")))
+                    t.IsRegular())
                 {
                     /// This is a regular test,
                     ///    not an internal/unpublished test, neither an auto action test

TBF/UI/Shared/BenchControlPanel.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2017 Senus Slovensko a.s.
+/// Copyright (c) 2013-2021 Senus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
@@ -183,14 +183,15 @@ namespace TBF.UI.Shared
 			}
 
             Program.MainWnd.CurrentProcedure = procedures[0];
+            if (procedures[0].GetTestInstances() == null)
+            {
+                procedures[0].UpdateTestInstances(TBF.BenchControl.StateMachine.LoopStartNames, TBF.BenchControl.StateMachine.LoopEndNames, null);
+            }
 
 			testComboBox.Items.Clear();
-			foreach (var test in procedures[0].Tests)
+            foreach (var tinst in procedures[0].GetTestInstances()) 
 			{
-				for (int i = 1; i <= test.Repeats; i++)
-				{
-					testComboBox.Items.Add(test.GetExpandedTestName(i));
-				}
+				testComboBox.Items.Add(tinst);
 			}
 
 			if (testComboBox.Items.Contains(oriTestName))
@@ -198,24 +199,10 @@ namespace TBF.UI.Shared
 				testComboBox.Text = oriTestName;
 				TestName = oriTestName;
 			}
-			else if (procedures[0].Tests.Count > 0)
+            else if (testComboBox.Items.Count > 0)
 			{
-				Test test = procedures[0].Tests[0];
-				string title;
-				if (test.Repeats == 1)
-				{
-					if (test.Part == 0)
-						title = test.Name;												/// Single test
-					else
-						title = string.Format("{0} ({1})", test.Name, test.Part);		/// A part of a single test
-				}
-				else
-				{
-					title = string.Format("{0} ({1}/{2})", test.Name, 1, test.Repeats);	/// More test repetitions
-				}
-
-				testComboBox.Text = title;
-				TestName = title;
+                testComboBox.Text = testComboBox.Items[0].ToString();
+                TestName = testComboBox.Items[0].ToString();
 			}
 			else
 			{

TBF/UI/Shared/TestProgressCtrl.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2015 Senus Slovensko a.s.
+/// Copyright (c) 2013-2021 Senus Slovensko a.s.
 ///
 using System;
 using System.Drawing;
@@ -29,28 +29,16 @@ namespace TBF.UI.Shared
 			}
 		}
 
-		public bool Selected;
-
-        int testId;
-        public int TestId { get { return testId; } }
-
-        string testName;
-        public string TestName { get { return testName; } }
-
-		int part;
-		public int Part { get { return part; } }
-
-		string title;
-		public string Title2 { get { return title; } }
-
-		int repetitionNr;
-		public int RepetitionNr { get { return repetitionNr; } }
-
-		public string Title { set { testNameLabel.Text = value; } }
+        public readonly string ComplTestName;
+        public readonly int TestId;
+        public readonly int Part;
+        public readonly int RepetitionNr;
 
 		public int Progress { set { testProgressBar.Value = value; } }
 		public ProgressBar TestProgressBar { get { return testProgressBar; } }
 
+        public bool Selected;
+
 		public TestProgressCtrl()
 		{
 			InitializeComponent();
@@ -58,16 +46,16 @@ namespace TBF.UI.Shared
 			this.TestResult = TestProgressCtrl.Result.NotDone;
 		}
 
-		public TestProgressCtrl(int testId, string testName, int part, string title, int repetitionNr, int testRepeats)
+        public TestProgressCtrl(string complTestName, int testId, int part, int repetitionNr)
 			: this()
 		{
-            this.testId = testId;
-			this.part = part;
-            this.testName = testName;
-			this.title = title;
-			this.repetitionNr = repetitionNr;
-            this.Title = title;
-		}
+            this.ComplTestName = complTestName;
+            this.TestId = testId;
+            this.Part = part;
+			this.RepetitionNr = repetitionNr;
+
+            testNameLabel.Text = complTestName;
+        }
 
 		private void TestProgressCtrl_Click(object sender, System.EventArgs e)
 		{

TBF/UI/TestProgressControls.cs

@@ -1,5 +1,5 @@
 ///
-/// Copyright (c) 2013-2015 Sensus Slovensko a.s.
+/// Copyright (c) 2013-2021 Sensus Slovensko a.s.
 ///
 using System;
 using System.Collections.Generic;
@@ -19,7 +19,7 @@ namespace TBF.UI
 		public TestProgressControls(Control parent)
 		{
 			this.parent = parent;
-			progresses  = null;
+            progresses = new List<TestProgressCtrl>();
 			currentProgress = null;
 
 			Bridge.ProcedureSelectedHandler += delegate(object sender, ProcedureSelectedEventArgs args)
@@ -67,78 +67,22 @@ namespace TBF.UI
 
         void ResetProgressBars(Config.Entities.Procedure procedure)
         {
-            foreach (var test in procedure.Tests)
-            {
-                var component = TbfComponents.FindComponent(test.Method);
-                if (component != null)
-                {
-                    test.IsOuterLoopStart = component is TBF.BenchControl.TestMethods.OuterLoop.Start.Component;
-                    test.IsOuterLoopEnd = component is TBF.BenchControl.TestMethods.OuterLoop.End.Component;
-                }
-            }
-
             parent.SuspendLayout();
 
             currentProgress = null;
             parent.Controls.Clear();
-            progresses = new List<TestProgressCtrl>();
-            bool isOuterLoopMode = false;
-            int outerLoopRepeats = 0;
+            progresses.Clear();
 
-            int i = 0;
-            while (i < procedure.Tests.Count)
+            if (procedure.GetTestInstances() == null)
             {
-                Config.Entities.Test test = procedure.Tests[i++];
+                procedure.UpdateTestInstances(TBF.BenchControl.StateMachine.LoopStartNames, TBF.BenchControl.StateMachine.LoopEndNames, null);
+            }
 
-                if (!isOuterLoopMode && test.IsOuterLoopStart)
-                {
-                    isOuterLoopMode = true;
-                    outerLoopRepeats = (i < procedure.Tests.Count) ? procedure.Tests[i].Repeats : 1;
-                    continue;
-                }
-                else if (isOuterLoopMode && test.IsOuterLoopEnd)
-                {
-                    isOuterLoopMode = false;
-                    continue;
-                }
-
-                int repeats = test.Repeats;
-                int newI = i;
-                for (int r = 1; r <=repeats ; r++)
-                {
-                    if (isOuterLoopMode)
-                    {
-                        int j = i - 1;
-                        while (j < procedure.Tests.Count)
-                        {
-                            Config.Entities.Test test2 = procedure.Tests[j++];
-
-                            if (test2.IsOuterLoopEnd)
-                            {
-                                if (r == repeats) newI = j;
-                                break;
-                            }
-
-                            string test2Name = Results.Utils.GetTestName(test2.Name, test2.Repeats, r);
-                            TestProgressCtrl progress =
-                                new TestProgressCtrl(test2.Id, test2Name, test2.Part, test2.GetExpandedTestName(r), r, test2.Repeats);
-                            progresses.Add(progress);
-                            parent.Controls.Add(progress);
-                            Console.WriteLine(test2Name);
-                        }
-                    }
-                    else
-                    {
-                        string testName = Results.Utils.GetTestName(test.Name, test.Repeats, r);
-                        TestProgressCtrl progress =
-                            new TestProgressCtrl(test.Id, testName, test.Part, test.GetExpandedTestName(r), r, test.Repeats);
-                        progresses.Add(progress);
-                        parent.Controls.Add(progress);
-                        Console.WriteLine(testName);
-                    }
-                }
-
-                i = newI;
+            foreach (var ti in procedure.GetTestInstances())
+            {
+                var progress = new TestProgressCtrl(ti.Name, ti.Test.Id, ti.Test.Part, ti.Repetition);
+                progresses.Add(progress);
+                parent.Controls.Add(progress);
             }
 
             parent.ResumeLayout();
@@ -177,7 +121,7 @@ namespace TBF.UI
 		{
             foreach (var prgrs in progresses)
             {
-				if (prgrs.TestName == args.TestName && prgrs.Part == args.Part)
+                if (prgrs.ComplTestName == args.TestName && prgrs.Part == args.Part && prgrs.RepetitionNr == args.RepetitionNr)
                 {
                     prgrs.Progress = args.Progress;
                     break;

Users/Users.csproj

@@ -19,7 +19,7 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
     <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DefineConstants>TRACE;DEBUG;TURA_IPERL_NEW;LANG_SK</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <Prefer32Bit>false</Prefer32Bit>
@@ -28,7 +28,7 @@
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
     <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
+    <DefineConstants>TRACE;TURA_IPERL_NEW;LANG_SK</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <Prefer32Bit>false</Prefer32Bit>