//            Copyright Keysight Technologies 2012-2019
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
using NUnit.Framework;
using System;
using System.Diagnostics;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Text.RegularExpressions;
using OpenTap.EngineUnitTestUtils;
using OpenTap.Plugins.BasicSteps;
using System.ComponentModel;
using System.Threading;
using OpenTap.Engine.UnitTests.TestTestSteps;
using System.Text;

namespace OpenTap.Engine.UnitTests
{
    /// <summary>
    ///This is a test class for TestPlanTest and is intended
    ///to contain all TestPlanTest Unit Tests
    ///</summary>
    [TestFixture]
    public class TestPlanTest 
    {


        public class TestStepExceptionTest : TestStep
        {
            public override void Run()
            {
                throw new Exception("test");
            }
        }

        public class TestStepPreExceptionTest : TestStep
        {
            public override void PrePlanRun()
            {
                throw new Exception("test");
            }
            public override void Run()
            {
            }
        }

        /// <summary>
        ///Gets or sets the test context which provides
        ///information about and functionality for the current test run.
        ///</summary>

        [Test]
        public void SaveLoadWithNestedTypes()
        {
            TestPlan plan = new TestPlan();
            plan.Steps.Add(new TestStepTest.NestedStep());
            plan.Steps.Add(new TestStepTest2.NestedStep());
            string fileName = Path.GetTempFileName();
            plan.Save(fileName);

            TestPlan plan2 = TestPlan.Load(fileName);

            Assert.AreEqual(plan.Steps.Count, plan2.Steps.Count);
        }

        [Test]
        public void ChildGetMethods()
        {
            TestPlan target = new TestPlan();
            target.Steps.Add(new TestStepTest());
            target.Steps.Add(new TestStepTest2());
            target.Steps.Add(new TestStepTest { Enabled = false });
            var recTest = new RecursiveTestStep();
            target.Steps.Add(recTest);
            var recursivelyLast = new TestStepTest3 { Enabled = false };
            recTest.ChildTestSteps.Add(new TestStepTest3());
            recTest.ChildTestSteps.Add(recursivelyLast);
            try
            {
                recTest.ChildTestSteps.Add(new TestStepTest());
                //throw new Exception("test exception"); saved for future conformance testing
            }
            catch (Exception e)
            {
                Assert.AreNotEqual(e.Message, "test exception");
            }
            Assert.AreEqual(2, recTest.RecursivelyGetChildSteps(TestStepSearch.All).Count());
            Assert.AreEqual(6, target.Steps.RecursivelyGetAllTestSteps(TestStepSearch.All).Count());
            Assert.AreEqual(4, target.Steps.RecursivelyGetAllTestSteps(TestStepSearch.EnabledOnly).Count());
            // saved for future.. Assert.AreEqual(2, target.Steps.RecursivelyGetAllTestSteps(TestStep.Search.NotEnabledOnly).Count());
            Assert.AreEqual(recursivelyLast, target.Steps.RecursivelyGetAllTestSteps(TestStepSearch.All).Last());
        }

        /// <summary>
        ///A test for Run
        ///</summary>
        [Test]
        [Pairwise]
        public void RunTest([Values(false, true)] bool open)
        {
            TestTraceListener trace = new TestTraceListener();
            Log.AddListener(trace);

            TestPlan target = new TestPlan();
            target.Steps.Add(new TestStepTest());

            ResultOrderTester orderTester = new ResultOrderTester();
            ResultSettings.Current.Add(orderTester);
            PlanRunCollectorListener pl = new PlanRunCollectorListener();
            if (open)
                target.Open();
            var planRun = target.Execute(new IResultListener[] { orderTester, pl });
            if (open)
            {
                Assert.IsTrue(orderTester.IsConnected);
                Assert.IsTrue(pl.IsConnected);
                target.Close();
            }
            Assert.AreEqual(true, orderTester.StepRunCompletedRan);
            Assert.AreEqual(true, orderTester.PlanRunCompletedRan);
            Log.RemoveListener(trace);
            ResultSettings.Current.Remove(orderTester);
            trace.AssertErrors(new string[] { "No instruments found.", "Keysight Internal! This version is not licensed. Do not distribute outside Keysight." });
            Assert.AreEqual(Verdict.Pass, planRun.Verdict);
            Assert.AreEqual(Verdict.Pass, pl.StepRuns.First().Verdict);
            ResultSettings.Current.Clear();
            Assert.AreEqual(0, orderTester.Errors.Count());
        }

        [Test]
        public void PrintTestPlanRunSummaryTest()
        {

            var testFile = new byte[1500];
            var testFileName = $"OpenTap.UnitTests.{nameof(PrintTestPlanRunSummaryTest)}.testFile.bin";
            File.Delete(testFileName);
            File.WriteAllBytes(testFileName, testFile);

            TestTraceListener trace = new TestTraceListener();
            Log.AddListener(trace);

            TestPlan target = new TestPlan();
            target.PrintTestPlanRunSummary = true;
            target.Steps.Add(new TestStepTest() {PublishArtifact = testFileName});
            PlanRunCollectorListener pl = new PlanRunCollectorListener();
            var planRun = target.Execute(ResultSettings.Current.Concat(new IResultListener[] { pl }));
            Log.Flush();
            Log.RemoveListener(trace);
            var summaryLines = trace.allLog.ToString().Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries).Where(l => l.Contains(": Summary ")).ToArray();
            Assert.AreEqual(6, summaryLines.Count(), "Did not find the expected number of summary lines in the log.");
            Assert.AreEqual(Verdict.Pass, pl.StepRuns.First().Verdict);
            Assert.IsTrue(summaryLines[4].Contains("1 artifacts registered"));
            Assert.IsTrue(summaryLines[5].Contains(testFileName));
            Assert.IsTrue(summaryLines[5].EndsWith("[1.5 kB]"));
        }
        
        [Test]
        public void TestRunSelectedResultParameter([Values(null, 1, 3)] int? runSelected)
        { 
            var plan = new TestPlan();
            var steps = Enumerable.Range(0, 10).Select(_ => new VerdictStep()).ToArray();
            plan.ChildTestSteps.AddRange(steps);

            HashSet<ITestStep> selectedSteps = null;
            if (runSelected.HasValue)
                selectedSteps = new HashSet<ITestStep>(steps.Take(runSelected.Value));
            var results = plan.Execute( Array.Empty<IResultListener>(), Array.Empty<ResultParameter>(), selectedSteps).Parameters;
            var result = results.FirstOrDefault(param => param.Name == TestPlanRun.SpecialParameterNames.StepOverrideList);
            if (runSelected.HasValue)
            {
                Assert.That(result, Is.Not.Null);
                var ids = result.Value.ToString().Split(',');
                Assert.That(ids.Length, Is.EqualTo(runSelected.Value));
                for (int i = 0; i < runSelected; i++)
                {
                    var id = steps[i].Id.ToString();
                    Assert.That(ids.Any(r => r == id));
                }
            }
            else
            {
                Assert.That(result, Is.Null);
            }
        }
        
        [Test]
        public void TestBreakConditionResultParameter([Values(true, false)] bool doBreak)
        { 
            var l = new PlanRunCollectorListener();
            var plan = new TestPlan();

            var sequenceStep = new SequenceStep();
            plan.ChildTestSteps.Add(sequenceStep);
            BreakConditionProperty.SetBreakCondition(sequenceStep, BreakCondition.BreakOnFail);

            var verdictStep = new VerdictStep() { VerdictOutput = doBreak ? Verdict.Fail : Verdict.Pass };
            sequenceStep.ChildTestSteps.Add(verdictStep);

            var run = plan.Execute(new[] { l });
            
            var breakResult = run.Parameters.FirstOrDefault(param => param.Name == TestPlanRun.SpecialParameterNames.BreakIssuedFrom);
            if (doBreak)
            {
                var stepRun = l.StepRuns.First(r => r.TestStepId == verdictStep.Id);
                Assert.That(breakResult, Is.Not.Null);
                Assert.That(breakResult.Value.ToString(), Is.EqualTo(stepRun.Id.ToString()));
            }
            else 
                Assert.That(breakResult, Is.Null);
        }

        [Test]
        public void TestCaughtBreakConditionNotPropagated([Values(true, false)] bool doCatch)
        {
            var l = new PlanRunCollectorListener();
            var plan = new TestPlan();

            var sequenceStep = new SequenceStep();
            plan.ChildTestSteps.Add(sequenceStep);

            var verdictStep = new VerdictStep() { VerdictOutput = Verdict.Fail };
            sequenceStep.ChildTestSteps.Add(verdictStep);

            BreakConditionProperty.SetBreakCondition(verdictStep, BreakCondition.BreakOnFail);
            BreakConditionProperty.SetBreakCondition(plan, BreakCondition.BreakOnFail);
            if (doCatch)
            {
                // Since sequence step breaks on error, it will 'catch' the break issued from verdictstep
                BreakConditionProperty.SetBreakCondition(sequenceStep, BreakCondition.BreakOnError); 
            }
            else
            {
                BreakConditionProperty.SetBreakCondition(sequenceStep, BreakCondition.BreakOnFail); 
            }
            
            var run = plan.Execute(new[] { l });

            var breakResult = run.Parameters.FirstOrDefault(param => param.Name == TestPlanRun.SpecialParameterNames.BreakIssuedFrom);
            if (doCatch)
            {
                Assert.That(breakResult, Is.Null);
            }
            else
            { 
                var stepRun = l.StepRuns.First(r => r.TestStepId == verdictStep.Id);
                Assert.That(breakResult, Is.Not.Null);
                Assert.That(breakResult.Value.ToString(), Is.EqualTo(stepRun.Id.ToString()));
            }
        }

        [Test]
        public void TestMoveSteps()
        {
            var plan = new TestPlan();
            var par = new ParallelStep();
            var repeat = new RepeatStep();
            var dialog = new DialogStep();
            var ifVerdict = new IfStep();

            plan.ChildTestSteps.Add(par);
            plan.ChildTestSteps.Add(repeat);
            repeat.ChildTestSteps.Add(dialog);
            repeat.ChildTestSteps.Add(ifVerdict);


            { // Set dialog as the input step for ifVerdict
                ifVerdict.InputVerdict.Step = dialog;
                Assert.That(ifVerdict.InputVerdict.Step, Is.EqualTo(dialog));
            }

            { // Move repeat step into the parallel step                        
                plan.ChildTestSteps.Remove(repeat);
                par.ChildTestSteps.Add(repeat);

                // Verify the step can still be computed after adding it back
                Assert.That(ifVerdict.InputVerdict.Step, Is.EqualTo(dialog));

                // after removing the dialog step the input step should be null.
                repeat.ChildTestSteps.Remove(dialog);
                Assert.That(ifVerdict.InputVerdict.Step, Is.Null);
            } 
        }

        [Test]
        public void TestPlanStepExceptionTest()
        {
            var preAbortTestPlan = EngineSettings.Current.AbortTestPlan;
            EngineSettings.Current.AbortTestPlan = default(EngineSettings.AbortTestPlanType);
            try
            {
                PlanRunCollectorListener pl = new PlanRunCollectorListener();
                TestPlan target = new TestPlan();
                target.Steps.Add(new TestStepExceptionTest());
                target.Steps.Add(new TestStepTest());

                ResultSettings.Current.Add(pl);
                target.Execute();
                ResultSettings.Current.Remove(pl);

                Assert.AreEqual(Verdict.Error, pl.StepRuns.ElementAt(0).Verdict, "Exception in teststep did not cause verdict to become 'Error'.");
                Assert.AreEqual(Verdict.Pass, pl.StepRuns.ElementAt(1).Verdict, "TestStep did not pass after previous step caused an exception.");

                ResultSettings.Current.Clear();
            }
            finally
            {
                EngineSettings.Current.AbortTestPlan = preAbortTestPlan;
            }
        }

        [Test]
        public void TestPlanExecuteResultListenerCheck()
        {
            // Verifies that only the ResultListeners added in execute are used, if that overload is selected.
            PlanRunCollectorListener pl1 = new PlanRunCollectorListener();
            PlanRunCollectorListener pl2 = new PlanRunCollectorListener();
            TestPlan target = new TestPlan();
            target.Steps.Add(new TestStepTest());
            ResultSettings.Current.Add(pl2);
            target.Open(new[] { pl1 });
            target.Execute(new[] { pl1 });
            target.Close();
            
            target.Execute(new[] { pl1 });

            ResultSettings.Current.Remove(pl2);
            Assert.AreEqual(0, pl2.StepRuns.Count);
            Assert.AreEqual(2, pl1.StepRuns.Count);
            Assert.AreEqual(true, pl1.WasOpened);
            Assert.AreEqual(false, pl2.WasOpened);
        }

        [Test]
        public void OpenAdditionalResources()
        {
            var instr1 = new DummyInstrument();
            var instr2 = new DummyInstrument();
            var instr3 = new DummyInstrument();
            var plan = new TestPlan();
            
            plan.Open();
            
            Assert.IsFalse(instr1.IsConnected);
            Assert.IsFalse(instr2.IsConnected);
            Assert.IsFalse(instr3.IsConnected);
            
            plan.Open(new IResource[]{instr1,instr2});
            Assert.IsTrue(instr1.IsConnected);
            plan.Open(new IResource[]{instr3,instr2});
            Assert.IsTrue(instr3.IsConnected);
            Assert.IsTrue(instr2.IsConnected);
            Assert.IsTrue(instr1.IsConnected);
            plan.Close();
            
            Assert.IsFalse(instr1.IsConnected);
            Assert.IsFalse(instr2.IsConnected);
            Assert.IsFalse(instr3.IsConnected);
        }

        [Test]
        public void TestPlanLogErrorTest()
        {
            TestTraceListener trace = new TestTraceListener();
            Log.AddListener(trace);

            TestPlan target = new TestPlan();
            target.Steps.Add(new TestStepTest());

            var planRun = target.Execute();

            Log.RemoveListener(trace);

            string logStr = trace.GetLog();

            Assert.IsFalse(Regex.IsMatch(logStr, "TestPlan\\s+; Error"));
        }

        [Test]
        public void TestPlanResourceCrashTest()
        {
            var inst = new InstrumentTest() {CrashPhase = InstrumentTest.InstrPhase.Open};
            var step = new InstrumentTestStep();
            step.Instrument = inst;
            
            var plan = new TestPlan();
            plan.ChildTestSteps.Add(step);

            string logString = null;
            InstrumentSettings.Current.Add(inst);
            try
            {
                TestTraceListener trace = new TestTraceListener();
                Log.AddListener(trace);
                var run = plan.Execute();
                Log.Flush();
                logString = trace.GetLog();
                var err = trace.ErrorMessage;
                Assert.AreEqual(Verdict.Error, run.Verdict);
                // improvement: only one error in the log.
                Assert.AreEqual(2, err.Count);
                // the log should not be really long.
                Assert.IsTrue(logString.Split('\n').Length < 70);
            }
            finally
            {
                InstrumentSettings.Current.Remove(inst);    
            }
        }

        [Test]
        public void TestPlanSaveLoadTest()
        {

            TestPlan target = new TestPlan();

            TestStepTest step1 = new TestStepTest();
            step1.TestPoints.Add(new TestStepTest.TestPoint { Channel = 12 });
            target.Steps.Add(step1);

            TestStepTest2 step2 = new TestStepTest2();
            step2.TestPoints.Add(new TestStepTest2.TestPoint { });
            step2.ObjectProperty = new TestStepTest2.SomeObject { };
            target.Steps.Add(step2);

            SubSpace.TestStepTest step3 = new SubSpace.TestStepTest();
            target.Steps.Add(step3);

            TestPlan loadedPlan;
            string xmlText;
            using (Stream str = new MemoryStream(20000))
            using (StreamReader reader = new StreamReader(str))
            {
                target.Save(str);
                str.Seek(0, 0);
                xmlText = reader.ReadToEnd();
                str.Seek(0, 0);
                loadedPlan = TestPlan.Load(str,target.Path);
            }
            Assert.AreEqual(loadedPlan.Steps.Count, target.Steps.Count);
            Assert.AreEqual(loadedPlan.Steps[0].Name, target.Steps[0].Name);
        }

        [Test]
        public void TestPlan_AbortIfNoResource()
        {
            PlanRunCollectorListener pl = new PlanRunCollectorListener();
            TestPlan target = new TestPlan();

            ScpiTestStep step1 = new ScpiTestStep();
            target.Steps.Add(step1);
            step1.Instrument = null;

            var t = Task<TestPlanRun>.Factory.StartNew(() =>
            {
                return target.Execute(ResultSettings.Current.Concat(new IResultListener[] { pl }));
            });
            t.Wait(1000);
            if (t.Status == TaskStatus.Running)
                Assert.Fail("TestPlan never completed.");
            Assert.AreEqual(0, pl.StepRuns.Count(), "Step was run although resource was not set");

        }

        [Test]
        public void TestResultOrderTester()
        {
            ResultOrderTester tester = new ResultOrderTester();
            var testTestPlanRun = new TestPlanRun(new TestPlan(), new List<IResultListener>(), DateTime.Now, Stopwatch.GetTimestamp());
            try
            {
                tester.OnTestPlanRunCompleted(testTestPlanRun, new MemoryStream());
                throw new Exception("This should not happen");
            }
            catch (InvalidOperationException)
            {
            }
            try
            {
                TestStepRun stepRun = new TestStepRun(new TestStepTest(), testTestPlanRun.Id);
                tester.OnTestStepRunCompleted(stepRun);
                throw new Exception("This should not happen");
            }
            catch (InvalidOperationException)
            {
            }
            var errs = tester.Errors;
            Assert.AreEqual(2, errs.Count());

        }

        class HashCheckResultListener : ResultListener
        {
            TestPlan plan;
            public HashCheckResultListener(TestPlan plan) => this.plan = plan;

            public override void OnTestPlanRunStart(TestPlanRun planRun)
            {
                string getHash(string testPlanXml)
                {
                    // this is the same code as inside TestPlanRun.
                    using (var algo = System.Security.Cryptography.SHA1.Create())
                        return BitConverter.ToString(algo.ComputeHash(System.Text.Encoding.UTF8.GetBytes(testPlanXml)), 0, 8).Replace("-", string.Empty);
                }

                var newxml = new TapSerializer().SerializeToString(plan);

                if (newxml != planRun.TestPlanXml)
                    planRun.MainThread.Abort(); // cause Verdict.Abort.

                if(planRun.Hash != getHash(newxml))
                    planRun.MainThread.Abort();

            }
        }

        [Test]
        public void TestPlanHash()
        {
            var plan = new TestPlan();
            var step = new LogStep { LogMessage = "A" };
            plan.ChildTestSteps.Add(step);
            plan.Open(new[] { new HashCheckResultListener(plan) });
            Assert.AreEqual(Verdict.NotSet, plan.Execute().Verdict);
            step.LogMessage = "B";
            Assert.AreEqual(Verdict.NotSet, plan.Execute().Verdict);
            plan.Close();
        }

        class AbortImmediatelyResultListener : ResultListener
        {
            public override void OnTestPlanRunStart(TestPlanRun planRun) => planRun.MainThread.Abort();
        }

        [Test]
        public void TestPlanAbortFromResultListener()
        {
            var plan = new TestPlan();
            plan.ChildTestSteps.Add(new DelayStep());
            var run = plan.Execute(new[] { new AbortImmediatelyResultListener() });
            Assert.AreEqual(Verdict.Aborted, run.Verdict);
        }

        /// <summary> Tests to see if a prerun error in a teststep results in the run of the result listeners.</summary>
        [Test]
        public void TestStepPrePostRunExceptionsIntoResultListener()
        {
            PlanRunCollectorListener pl = new PlanRunCollectorListener();
            TestPlan testPlan = new TestPlan();
            testPlan.ChildTestSteps.Add(new TestStepPreExceptionTest());
            ResultSettings.Current.Add(pl);
            testPlan.Execute();
            ResultSettings.Current.Remove(pl);

            Assert.AreEqual(0, pl.StepRuns.Count);
            Assert.AreEqual(1, pl.PlanRuns.Count);
            Assert.AreEqual(true, pl.PlanRuns.ElementAt(0).FailedToStart);
        }

        [Test]
        public void MissingInstReferencesIntoResultListener()
        {
            InstrumentSettings.Current.Clear();
            PlanRunCollectorListener pl = new PlanRunCollectorListener();
            TestPlan testPlan = new TestPlan();
            ScpiTestStep step = new ScpiTestStep();

            testPlan.ChildTestSteps.Add(step);
            ResultSettings.Current.Add(pl);
            var tpr = testPlan.Execute();
            ResultSettings.Current.Remove(pl);

            Assert.IsTrue(tpr.FailedToStart);
        }

        [Test]
        public void InstExceptionIntoResultListener()
        {
            PlanRunCollectorListener pl = new PlanRunCollectorListener();
            TestPlan testPlan = new TestPlan();
            InstrumentTestStep step = new InstrumentTestStep();
            InstrumentTest openCrash = new InstrumentTest { CrashPhase = InstrumentTest.InstrPhase.Open };
            step.Instrument = openCrash;

            testPlan.ChildTestSteps.Add(step);
            ResultSettings.Current.Add(pl);
            var planrun = testPlan.Execute();
            ResultSettings.Current.Remove(pl);

            Assert.AreEqual(1, pl.StepRuns.Count);
            Assert.AreEqual(1, pl.PlanRuns.Count);
            Assert.AreEqual(Verdict.Error, pl.PlanRuns.ElementAt(0).Verdict);
        }

        [Test]
        public void BadResultListenerIntoGoodResultListener()
        {
            PlanRunCollectorListener pl = new PlanRunCollectorListener();
            TestPlan testPlan = new TestPlan();

            testPlan.ChildTestSteps.Add(new TestStepTest());
            ResultSettings.Current.Add(pl);

            // Now, we add a resultlistener that has exceptions
            var erl = new resultListenerCrash { CrashResultPhase = resultListenerCrash.ResultPhase.Open };
            ResultSettings.Current.Add(erl);

            testPlan.Execute();

            ResultSettings.Current.Clear();

            Assert.AreEqual(0, pl.StepRuns.Count);
            Assert.AreEqual(1, pl.PlanRuns.Count);
            Assert.AreEqual(true, pl.PlanRuns.ElementAt(0).FailedToStart);
        }

        /// <summary>
        /// Run child steps in a loop.
        /// </summary>
        [AllowAnyChild]
        class RepeatRunChildSteps : TestStep
        {
            public int Repeats { get; set; }
            public override void Run()
            {
                for(int i = 0; i < Repeats; i++)
                {
                    RunChildSteps();
                }
            }
        }

        /// <summary>
        /// A result listener that just takes a bit of time in the result processing thread.
        /// Not too much or the test is too slow.
        /// </summary>
        class SlowResultListener : ResultListener
        {
            public override void OnTestStepRunCompleted(TestStepRun stepRun)
            {
                base.OnTestStepRunCompleted(stepRun);
            }

            public override void OnTestStepRunStart(TestStepRun stepRun)
            {
                base.OnTestStepRunStart(stepRun);
                TapThread.Sleep(10);
            }
        }

        /// <summary>
        /// Issue (#3898) is caused by a slight delay in the result processing thread that provokes a race condition 
        /// this affects steps that run child steps multiple times without waiting for defer completion.
        /// </summary>
        [Test]
        public void RepeatChildStepsFailure()
        {
            
            var plan = new TestPlan();
            var repeat = new RepeatRunChildSteps { Repeats = 10 };
            var repeat2 = new RepeatRunChildSteps { Repeats = 10 };
            repeat2.ChildTestSteps.Add(new SequenceStep());
            repeat.ChildTestSteps.Add(repeat2);
            plan.ChildTestSteps.Add(repeat);
            var run = plan.Execute(new IResultListener[] { new SlowResultListener() });
            Assert.AreEqual(Verdict.NotSet, run.Verdict);
        }
        /// <summary>
        /// Tests that if the SuggestedNextStep is set to the current ID, thn the testStep will be repeated. 
        /// </summary>
        [Test]
        public void SuggestedNextStepTest()
        {
            using (Session.Create(SessionOptions.OverlayComponentSettings))
            { 
                var plan = new TestPlan();
                var parallelStep = new ParallelStep();
                var nextStepRepeater = new SuggestedNextStepRepeater();
                nextStepRepeater.RepeatCount = 10;
                parallelStep.ChildTestSteps.Add(nextStepRepeater);
                plan.ChildTestSteps.Add(parallelStep);
                PlanRunCollectorListener planRunListener = new PlanRunCollectorListener();
                ResultSettings.Current.Add(planRunListener);

                var planRun = plan.Execute();
                
                var stepRuns = planRunListener.StepRuns;

                //We compare repeatcount + 1 as the parallelStep is also counted in StepsRun.
                Assert.AreEqual(nextStepRepeater.RepeatCount + 1, stepRuns.Count);            
            }
        }

        public class SuggestedNextStepRepeater : TestStep
        {
            public int RepeatCount { get; set; }
            public int Repeats { get; set; } 

            public override void Run()
            {
                if(Repeats < RepeatCount -1)
                {
                    this.StepRun.SuggestedNextStep = this.Id;
                    Repeats++;
                }
            }
        }

        public class VerifyTestStep : TestStep
        {
            public static int Value = 0;

            public int Prop { get; set; }

            public VerifyTestStep()
            {
                Prop = 123;
            }

            public override void Run()
            {
                Value = Prop;
            }
        }

        class PrePostPlanTestStep : TestStep
        {
            public bool VerifyPrePlanRun;
            public bool VerifyPostPlanRun;
            public bool VerifyRun;
            public bool VerifyDefer;
            public override void PrePlanRun()
            {
                base.PrePlanRun();
                VerifyPrePlanRun = false;
                VerifyPostPlanRun = false;
                VerifyRun = false;
                VerifyDefer = false;
                Assert.IsNotNull(PlanRun);
                Assert.IsNull(StepRun);
                VerifyPrePlanRun = true;
            }
            public override void Run()
            {
                VerifyRun = true;
                Assert.IsNotNull(PlanRun);
                Assert.IsNotNull(StepRun);
                Results.Defer(() =>
                {
                    Assert.IsNotNull(PlanRun);
                    Assert.IsNotNull(StepRun);
                    VerifyDefer = true;
                    UpgradeVerdict(Verdict.Pass);
                });
            }

            public override void PostPlanRun()
            {
                base.PostPlanRun();
                Assert.IsNotNull(PlanRun);
                Assert.IsNull(StepRun);
                VerifyPostPlanRun = true;
            }
        }

        [Test]
        public void VerifyPrePostPlanRun()
        {
            var tp = new TestPlan();
            var step = new PrePostPlanTestStep();
            tp.ChildTestSteps.Add(step);
            for (int i = 0; i < 4; i++)
            {
                var run = tp.Execute();
                Assert.AreEqual(Verdict.Pass, run.Verdict);
                Assert.IsTrue(step.VerifyDefer);
                Assert.IsTrue(step.VerifyRun);
                Assert.IsTrue(step.VerifyPostPlanRun);
                Assert.IsTrue(step.VerifyPrePlanRun);
            }
        }

        class DeferredResultsStep : TestStep
        {
            public bool IsDone = false;
            public Semaphore sem = new Semaphore(0, 1);
            public Semaphore canFinish = new Semaphore(0, 1);
            public override void Run()
            {
                Results.Defer(() =>
                {
                    sem.Release();
                    canFinish.WaitOne();
                });
            }
        }

        [Test]
        public void DeferAndAbort([Values(true, false)] bool WrapSequence)
        {
            var defer = new DeferredResultsStep();
            var plan = new TestPlan();
            if (WrapSequence)
            {
                var sequenceStep = new SequenceStep();
                sequenceStep.ChildTestSteps.Add(defer);
                plan.ChildTestSteps.Add(sequenceStep);
            }
            else
            {
                plan.ChildTestSteps.Add(defer);
            }

            var sem2 = new Semaphore(0, 1);
            var thread = TapThread.Start(() =>
            {
                try
                {
                    plan.Execute();
                }
                finally
                {
                    sem2.Release();
                }
            });
            defer.sem.WaitOne();
            thread.Abort();
            try
            {
                bool hangs = sem2.WaitOne(50) == false;
                Assert.IsTrue(hangs, "Deferred results step should wait.");
            }
            finally
            {
                defer.canFinish.Release();    
            }
            bool isDone = sem2.WaitOne(10000);
            if(!isDone)
                Assert.Fail("Test plan timed out");
            Assert.IsTrue(isDone);
        }
        [Test]
        public void RecursiveTestPlanReferenceTest()
        {
            TestPlan plan = new TestPlan();
            var step = new TestPlanReference();
            string filePath = "plan.TestPlan";
            step.Filepath.Text = filePath;
            plan.Steps.Add(step);
            plan.Save(filePath);

            // this threw an exception at one point.
            step.LoadTestPlan();

            TestTraceListener trace = new TestTraceListener();
            Log.AddListener(trace);
            var plan2 = TestPlan.Load(filePath);
            Log.RemoveListener(trace);
            StringAssert.Contains("Test plan reference is trying to load itself leading to recursive loop.", trace.GetLog());
            File.Delete(filePath);
        }
        
        [Test]
        public void ParameterizedTestPlanReferenceTest()
        {
            var path = Path.GetTempFileName();
            
            { // Create test plan with external parameter
                var subplan = new TestPlan();
                var logStep = new LogStep() { LogMessage = "Initial Value" };
                var logInfo = TypeData.GetTypeData(logStep);
                subplan.ChildTestSteps.Add(logStep);
                subplan.ExternalParameters.Add(logStep, logInfo.GetMember(nameof(logStep.LogMessage)));
                subplan.Save(path); 
            }

            try
            { // Add the created test plan as a child step of a sweep loop
                var reference = new TestPlanReference { Filepath = { Text = path } };
                var sweep = new SweepLoop() {
                    ChildTestSteps =
                    {
                        reference
                    }
                }; 

                string GetLogMessageParameter(AnnotationCollection a)
                {
                    var avail = a.Get<IMembersAnnotation>().Members.FirstOrDefault(m => m.Name == "Sweep Parameters")
                        ?.Get<IAvailableValuesAnnotationProxy>();
                    var v = avail?.AvailableValues.FirstOrDefault(v => v.Name == "ExpandedMemberData");
                    return v?.Get<IStringValueAnnotation>()?.Value;
                }

                var a = AnnotationCollection.Annotate(sweep);
                Assert.That(GetLogMessageParameter(a), Is.Null);
                reference.LoadTestPlan();
                a.Read();
                Assert.That(GetLogMessageParameter(a), Is.EqualTo("Log Message"));
            }
            finally
            {
                File.Delete(path);
            }
        }
        
        [Test]
        public void RelativeTestPlanTest()
        {
            int depth = 10;
            string path = "RelativeTestPlanTest_TestDir";

            for (int i = 0; i < depth; i++)
            {
                TestPlan plan = new TestPlan();
                Directory.CreateDirectory(path);
                var filepath = Path.Combine(path, "plan.TestPlan");
                if (i < depth - 1)
                {
                    var step = new TestPlanReference();
                    step.Filepath.Text = "<TestPlanDir>/TestDir/plan.TestPlan";
                    plan.Steps.Add(step);
                }
                else
                {
                    var step = new DelayStep();
                    step.DelaySecs = 0.001;
                    plan.Steps.Add(step);

                }

                plan.Save(filepath);
                path = Path.Combine(path, "TestDir");
            }
            var bigplan = TestPlan.Load("RelativeTestPlanTest_TestDir/plan.TestPlan");
            var run = bigplan.Execute();
            Assert.AreEqual(depth, run.StepsWithPrePlanRun.Count);
            Directory.Delete("RelativeTestPlanTest_TestDir", true);

        }
        [Test]
        public void SweepDynamic()
        {
            string TempName = Path.GetTempFileName();

            TestPlan tp = new TestPlan();
            tp.ChildTestSteps.Add(new VerifyTestStep());

            var delaystep = tp.ChildTestSteps.First() as VerifyTestStep;

            tp.ExternalParameters.Add(delaystep, TypeData.GetTypeData(delaystep).GetMember("Prop"), "Prop");
            tp.Save(TempName);

            // Sanity check to verify that the step itself works
            tp.ExternalParameters.Entries[0].Value = 1234;
            VerifyTestStep.Value = 0;
            var planrun = tp.Execute();
            Assert.AreEqual(1234, VerifyTestStep.Value, "Wrong value before serialization");

            // Test running after construction by code
            tp = new TestPlan();

            var step = new OpenTap.Plugins.BasicSteps.TestPlanReference();
            tp.ChildTestSteps.Add(step);
            step.Filepath.Text = TempName;
            step.LoadTestPlan();

            // The step is now replaced
            ITestStep step2 = tp.ChildTestSteps.First();

            Assert.AreEqual(1, step2.ChildTestSteps.Count, "Number of childsteps");
            Assert.IsNotNull(TypeData.GetTypeData(step2).GetMember("Prop"), "Could not find external parameter property on testplan");

            var sweep = new OpenTap.Plugins.BasicSteps.SweepLoop();

            tp.ChildTestSteps.Add(sweep);
            tp.ChildTestSteps.Remove(step2);
            sweep.ChildTestSteps.Add(step2);

            sweep.SweepParameters = new List<OpenTap.Plugins.BasicSteps.SweepParam> { new OpenTap.Plugins.BasicSteps.SweepParam(new List<IMemberData> {  TypeData.GetTypeData(step2).GetMember("Prop") }, 1337) };

            VerifyTestStep.Value = 0;
            tp.Execute();
            Assert.AreEqual(1337, VerifyTestStep.Value, "Wrong value after first run");

            string TempName2 = Path.GetTempFileName();
            tp.Save(TempName2);

            // Test running after deserialization
            tp = TestPlan.Load(TempName2);
            VerifyTestStep.Value = 0;
            tp.Execute();
            Assert.AreEqual(1337, VerifyTestStep.Value, "Wrong value after deserialization");
        }

        [Test]
        public void NullResourceTest()
        {
            InstrumentSettings.Current.Clear();
            try
            {
                InstrumentSettings.Current.Add(new InstrumentTest() { CrashPhase = InstrumentTest.InstrPhase.Open });
                // Plan with 4 steps.
                //> Sequence   disabled
                //   > Scpi    enabled
                //> Scpi       disabled
                //> LogStep    enabled
                TestPlan plan = new TestPlan();
                ScpiTestStep step1 = new ScpiTestStep { Enabled = true, Instrument = null };
                LogStep step2 = new LogStep { Enabled = true };
                ScpiTestStep step3 = new ScpiTestStep { Enabled = false, Instrument = null };
                InstrumentTestStep step4 = new InstrumentTestStep() { Instrument = InstrumentSettings.Current.First(), Enabled = false };
                SequenceStep parent = new SequenceStep { Enabled = false };
                parent.ChildTestSteps.Add(step1);

                plan.ChildTestSteps.Add(parent);
                plan.ChildTestSteps.Add(step2);
                plan.ChildTestSteps.Add(step3);
                plan.ChildTestSteps.Add(step4);

                var planRun = plan.Execute();
                Assert.AreEqual(Verdict.NotSet, planRun.Verdict);

                plan.Open();
                Assert.IsFalse(InstrumentSettings.Current.First().IsConnected);
                var planRun2 = plan.Execute();

                plan.Close();
                Assert.AreEqual(Verdict.NotSet, planRun2.Verdict);
            }
            finally
            {
                InstrumentSettings.Current.Clear();
            }
        }

        public class DelegateStep : TestStep
        {
            [System.Xml.Serialization.XmlIgnore]
            [Browsable(true)]
            public Func<Verdict> Action { get; set; }
            [Browsable(true)]
            [System.Xml.Serialization.XmlIgnore]
            public Action Action2 { get; set; }
            [Browsable(true)]
            public void Action3()
            {
                Log.Info("Action3 called");
            }
            public DelegateStep()
            {
                Action2 = () => Log.Info("Action2 called");
                Action = () => Verdict.Error;
            }
            public override void Run()
            {
                Thread.Sleep(10);
                Verdict = Action();
                Thread.Sleep(10);
                
            }
        }


        [Test]
        public void ChildITestStepLazy()
        {
            var prevResourceManager = EngineSettings.Current.ResourceManagerType;
            try
            {
                 
                EngineSettings.Current.ResourceManagerType = new LazyResourceManager();
                ChildITestStep();

            }
            finally
            {
                EngineSettings.Current.ResourceManagerType = prevResourceManager;
            }
        }
        
        [Test]
        public void ChildITestStep()
        {
            // Trigger issue when running child steps that is an ITestStep.
            SequenceStep seq = new SequenceStep();
            TestPlan plan = new TestPlan();

            var instr = new InterfaceTestInstrument();
            
            Verdict checkInstr()
            {
                if (EngineSettings.Current.ResourceManagerType is LazyResourceManager)
                {
                    return instr.IsConnected ? Verdict.Fail : Verdict.Pass;
                }
                return instr.IsConnected ? Verdict.Pass : Verdict.Fail;
            }

            var step = new TestITestStep();
            step.Instrument = instr;
            plan.Steps.Add(new DelegateStep { Action = checkInstr });
            plan.Steps.Add(seq);
            plan.Steps.Add(new DelegateStep { Action = checkInstr });
            seq.ChildTestSteps.Add(step);
            
            var run = plan.Execute();
            Assert.IsTrue(run.Verdict == Verdict.Pass);
            Assert.IsTrue(step.WasRun);
                        
            // Trigger issue with cycle on step.Parent / step.Parent.ChildTestSteps.
            TestTraceListener trace = new TestTraceListener();
            Log.AddListener(trace);
            var file = "ChildITestStep.TapPlan";
            plan.Save(file);
            Log.RemoveListener(trace);
            File.Delete(file);
            StringAssert.Contains("Cycle detected", trace.GetLog());

            // Trigger possible issue with null Name.
            Assert.IsTrue(string.IsNullOrWhiteSpace(step.GetFormattedName()));

        }

        [Test]
        public void TestChildStepsChanged()
        {
            List<TestStepList.ChildStepsChangedAction> lst = new List<TestStepList.ChildStepsChangedAction>();

            var a = new SweepLoop();
            a.ChildTestSteps.ChildStepsChanged += (s, action, obj, index) => lst.Add(action);
            var b = new SequenceStep();
            var c = new SequenceStep();
            a.ChildTestSteps.Add(b);
            Assert.AreEqual(1, lst.Count);
            var tl2 = new TestStepList();
            tl2.ChildStepsChanged += (s, action, obj, index) => lst.Add(action);
            tl2.Add(c);
            a.ChildTestSteps = tl2;
            c.ChildTestSteps.Add(b);
            c.ChildTestSteps.Remove(b);
            c.ChildTestSteps = new TestStepList();

            Assert.AreEqual(6, lst.Count);
            Assert.IsTrue(lst.Contains(TestStepList.ChildStepsChangedAction.ListReplaced));
            Assert.IsTrue(lst.Contains(TestStepList.ChildStepsChangedAction.RemovedStep));
            Assert.IsTrue(lst.Contains(TestStepList.ChildStepsChangedAction.AddedStep));
            Assert.AreEqual(2, lst.Count(x => x == TestStepList.ChildStepsChangedAction.ListReplaced));
        }

        /// <summary> Test running a sub-section of a test plan with an overload of TestPlan.Execute.</summary>
        [Test]
        public void SubPlanRunTest()
        {
            SequenceStep seq = new SequenceStep();
            TestPlan plan = new TestPlan();
            var step = new TestITestStep
            {
                Instrument = new InterfaceTestInstrument()
            };

            plan.Steps.Add(seq);
            seq.ChildTestSteps.Add(step);
            var run = plan.Execute(ResultSettings.Current, stepsOverride: new HashSet<ITestStep>(new[] { step }));
            
            Assert.IsTrue(run.Verdict < Verdict.Pass);
            Assert.IsTrue(step.WasRun);
            Assert.AreEqual(1, run.StepsWithPrePlanRun.Count);
        }

        [AllowAnyChild]
        internal class TestSubStep : TestStep
        {
            internal static int PreRuns = 0;
            internal static int Runs = 0;

            public override void PrePlanRun()
            {
                base.PrePlanRun();
                PreRuns++;
            }

            public override void PostPlanRun()
            {
                base.PostPlanRun();
            }

            public override void Run()
            {
                Runs++;
                RunChildSteps();
            }

            internal static void Clear()
            {
                PreRuns = 0;
                Runs = 0;
            }
        }

        /// <summary> Test running a sub-section of a test plan with an overload of TestPlan.Execute.</summary>
        [Test]
        public void SubPlanRunTest2()
        {
            TestPlan plan = new TestPlan();

            TestSubStep.Clear();

            var s = new TestSubStep();
            s.ChildTestSteps.Add(new TestSubStep());
            plan.ChildTestSteps.Add(s);
            plan.ChildTestSteps.Add(new TestSubStep());
            
            var run = plan.Execute(ResultSettings.Current, stepsOverride: new HashSet<ITestStep>(plan.ChildTestSteps));

            Assert.AreEqual(3, TestSubStep.PreRuns);
            Assert.AreEqual(3, TestSubStep.Runs);
            Assert.AreEqual(3, run.StepsWithPrePlanRun.Count);
        }

        /// <summary> Test running a sub-section of a test plan with an overload of TestPlan.Execute.</summary>
        [Test]
        public void SubPlanRunTest3()
        {
            TestPlan plan = new TestPlan();

            TestSubStep.Clear();

            var s = new TestSubStep();
            var sub = new TestSubStep();
            s.ChildTestSteps.Add(sub);
            plan.ChildTestSteps.Add(s);
            plan.ChildTestSteps.Add(new TestSubStep());
            
            var run = plan.Execute(ResultSettings.Current, stepsOverride: new HashSet<ITestStep>(new [] { sub, sub, sub }));

            Assert.AreEqual(1, TestSubStep.PreRuns);
            Assert.AreEqual(1, TestSubStep.Runs);
            Assert.AreEqual(1, run.StepsWithPrePlanRun.Count);
        }

        [Test]
        public void ComponentSettingMetadataTest()
        {
            UserInput.SetInterface(new ComponentSettingPrompt());
            try
            {
                TestComponentSettingList.Current.Clear();
                TestComponentSettingList.Current.Add(new TestComponentSetting());

                EngineSettings.Current.PromptForMetaData = true;

                {
                    var plan = new TestPlan();
                    plan.Steps.Add(new ComponentSettingStep());

                    var run = plan.Execute();
                    Assert.IsFalse(run.FailedToStart);
                    Assert.AreEqual(Verdict.Pass, run.Verdict);
                }

                TestComponentSettingList.Current.OfType<TestComponentSetting>().ForEach(f => f.MetaComment = "Test meta data comment");

                {
                    var plan = new TestPlan();
                    plan.Steps.Add(new ComponentSettingStep());

                    {
                        var run = plan.Execute();
                        Assert.IsFalse(run.FailedToStart);
                        Assert.AreEqual(Verdict.Pass, run.Verdict);
                    }
                }
            }
            finally
            {
                UserInput.SetInterface(null);
                EngineSettings.Current.PromptForMetaData = false;
            }
        }

        class CheckAllowEditStep : OpenTap.TestStep
        {
            public bool? allowedEdit;
            public override void Run()
            {
                allowedEdit = GetParent<TestPlan>().AllowEdit;
                UpgradeVerdict(Verdict.Pass);

            }
        }

        [Test]
        public void EditWhileBreak([Values(true,false)] bool allowEdit)
        {
            var plan = new TestPlan();
            CheckAllowEditStep checkStep = new CheckAllowEditStep();
            plan.ChildTestSteps.Add(checkStep);
            plan.BreakOffered += PlanOnBreakOffered;
            plan.AllowEditWhilePaused = allowEdit;
            bool? allowedEdit = false;
            void PlanOnBreakOffered(object sender, BreakOfferedEventArgs e)
            {
                allowedEdit = plan.AllowEdit;
            }
            Assert.AreEqual(Verdict.Pass, plan.Execute().Verdict);

            // allow edit while paused and AllowEditWhilePaused is true.
            Assert.AreEqual(allowEdit, allowedEdit);

            // never allow edit while running.
            Assert.AreEqual(false, checkStep.allowedEdit);
        }

        [Test]
        public void DutPromptMetadataTest()
        {
            UserInput.SetInterface(new DutInfoPrompt());

            try
            {
                DutSettings.Current.Clear();
                DutSettings.Current.Add(new TestDut());

                EngineSettings.Current.PromptForMetaData = true;

                {
                    var plan = new TestPlan();
                    plan.Steps.Add(new DutStep() { Dut = DutSettings.Current.OfType<TestDut>().FirstOrDefault() });

                    var run = plan.Execute();
                    Assert.IsFalse(run.FailedToStart);
                    Assert.AreEqual(Verdict.Pass, run.Verdict);
                }

                DutSettings.Current.OfType<TestDut>().ToList().ForEach(f => f.Comment = "test");

                {
                    var plan = new TestPlan();
                    plan.Steps.Add(new DutStep() { Dut = DutSettings.Current.OfType<TestDut>().FirstOrDefault() });

                    plan.Open();

                    {
                        var run = plan.Execute();
                        Assert.IsFalse(run.FailedToStart);
                        Assert.AreEqual(Verdict.Pass, run.Verdict);
                    }

                    {
                        var run = plan.Execute();
                        Assert.IsFalse(run.FailedToStart);
                        Assert.AreEqual(Verdict.Pass, run.Verdict);
                    }

                    plan.Close();
                }
            }
            finally
            {
                UserInput.SetInterface(null);
                EngineSettings.Current.PromptForMetaData = false;
            }
        }

        public class StepWithArray : TestStep
        {
            public double[] ArrayValues { get; set; } = Array.Empty<double>();
            public override void Run()
            {
                ArrayValues = new double[] { 1, 2, 3, 4, 5, 6 };
            }
        }

        [Test]
        public void TestStepWithArray()
        {
            PlanRunCollectorListener pl = new PlanRunCollectorListener();
            var arrayStep = new StepWithArray();
            var plan = new TestPlan();
            plan.ChildTestSteps.Add(arrayStep);
            var planrun = plan.Execute(new[] { pl });

            var steprun = pl.StepRuns.First();
            Assert.IsTrue(steprun.Parameters["ArrayValues", ""].ToString() == new NumberFormatter(System.Globalization.CultureInfo.CurrentCulture){UseRanges = false}.FormatRange(arrayStep.ArrayValues));
        }

        [Test]
        [Ignore("This test is very unstable in limited CPU situations. (for example on a server that is already busy with other things)")]
        public void TestPlanDeferError()
        {
            //
            // This unit test verifies that the verdict of the test plan behaves predictably when a test step throws an exception or aborts the plan
            // during defer actions. It also tests what happens in general when a step is being aborted when something else is happening in parallel.
            //

            /* // instabilities can be tested by doing a bunch of processing in other threads while testing.
            bool workhard = true;
            for(int i = 0; i < 16; i++)
            {
                TapThread.Start(() =>
                {
                    while (workhard)
                    {
                        Enumerable.Range(0, 1000).Count().ToString().GetHashCode();
                    }
                });
            }*/
            var plan = new TestPlan();
            var err = new ThrowInDefer() { WaitMs = 10 };
            var delay = new DelayStep() { DelaySecs = 1.0 };
            
            
            plan.ChildTestSteps.Add(err);
            plan.ChildTestSteps.Add(delay);
            
            var prevAbortPlanType = EngineSettings.Current.AbortTestPlan;
            var sw = Stopwatch.StartNew();
            // The abort mode decides which verdict the plan but also the delay step will get.
            var abortModes = new[] { EngineSettings.AbortTestPlanType.Step_Error, (EngineSettings.AbortTestPlanType)0 };
            foreach(var abortMode in abortModes)
            {
                EngineSettings.Current.AbortTestPlan = abortMode;
                for (int i = 0; i < 5; i++)
                {
                    bool isErrorDuringDelay = i != 4;
                    err.Throw = i % 2 == 0;
                    if (!isErrorDuringDelay)
                    {
                        // in this case the error will happen after delay has run
                        err.WaitMs = 50;
                        delay.DelaySecs = 0;
                    }
                    else
                    {
                        // in this case the error will happen during delay
                        err.WaitMs = 10;
                        delay.DelaySecs = 1.0;
                    }

                    if(isErrorDuringDelay && abortMode.HasFlag(EngineSettings.AbortTestPlanType.Step_Error) == false)
                    {
                        // since we dont abort on step errors, we dont want to wait 1s for this.
                        delay.DelaySecs = 0.1;
                    }

                    
                    for (int iterations = 0; iterations < 2; iterations++)
                    {
                        // Iterate a bit to faster catch race condition errors.
                        PlanRunCollectorListener pl = new PlanRunCollectorListener();
                        TestPlanRun planRun = plan.ExecuteAsync(new[] { (IResultListener)pl }, null, null, CancellationToken.None).Result;
                        
                        var delayRun = pl.StepRuns.FirstOrDefault(x => x.TestStepId == delay.Id);
                        var errorStepRun = pl.StepRuns.FirstOrDefault(x => x.TestStepId == err.Id);

                        // The error step verdict is always 'Error'.
                        Assert.AreEqual(Verdict.Error, errorStepRun.Verdict);

                        // The plan verdict depends on abortMode.
                        if (abortMode.HasFlag(EngineSettings.AbortTestPlanType.Step_Error))
                            Assert.AreEqual(Verdict.Aborted, planRun.Verdict);
                        else
                            Assert.AreEqual(Verdict.Error, planRun.Verdict);

                        // the verdict of delayRun depends on if the delay step completed before the error or abortMode.
                        if (abortMode.HasFlag(EngineSettings.AbortTestPlanType.Step_Error))
                        {
                            if (isErrorDuringDelay)
                                Assert.AreEqual(Verdict.Aborted, delayRun.Verdict);
                            else
                                Assert.AreEqual(Verdict.NotSet, delayRun.Verdict);
                        }
                        else
                            Assert.AreEqual(Verdict.NotSet, delayRun.Verdict);

                    }
                }
            }
            EngineSettings.Current.AbortTestPlan = prevAbortPlanType;
            Debug.WriteLine("TestPlanDeferError {0}", sw.Elapsed);
            //workhard = false;
        }

        class ComponentSettingPrompt : IUserInputInterface
        {
            public void RequestUserInput(object dataObject, TimeSpan Timeout, bool modal)
            {
                var sub = AnnotationCollection.Annotate(dataObject).Get<IForwardedAnnotations>().Forwarded.ToArray();
                foreach(string name in new []{"MetaComment", "MetaComment2"}){
                    var comments = sub.Where(x => x.Get<IMemberAnnotation>().Member.Name == name);
                    Assert.AreEqual(1, comments.Count());
                    var comment = comments.First();

                    Assert.IsNotNull(comment != null);
                    comment.Get<IStringValueAnnotation>().Value = "Just another meta comment";
                    comment.Write();
                }
                
            }
        }

        public class TestComponentSettingList : ComponentSettingsList<TestComponentSettingList, TestComponentSetting> { }

        public class TestComponentSetting : ComponentSettings<TestComponentSetting>
        {
            [MetaData(true)]
            [Display("MetaComment", Description: "Some comment for meta data")]
            public string MetaComment { get; set; }
            
            [MetaData(true)]
            [Display("MetaComment2", Description: "Some comment for meta data 2")]
            public string MetaComment2 { get; set; }

            public TestComponentSetting() { }
        }

        public class ComponentSettingStep : TestStep
        {
            public override void Run()
            {
                if (string.Compare("Just another meta comment", TestComponentSetting.Current.MetaComment, true) != 0)
                    throw new InvalidOperationException();
                if (string.Compare("Just another meta comment", TestComponentSetting.Current.MetaComment2, true) != 0)
                    throw new InvalidOperationException();
                UpgradeVerdict(Verdict.Pass);
            }
        }

        class DutInfoPrompt : IUserInputInterface
        {
            public void RequestUserInput(object dataObject, TimeSpan Timeout, bool modal)
            {
                var sub = AnnotationCollection.Annotate(dataObject).Get<IForwardedAnnotations>().Forwarded.ToArray();
                var comment = sub.First(x => x.Get<IMemberAnnotation>().Member.Name == "Comment");
                Assert.IsNotNull(comment != null);
                comment.Get<IStringValueAnnotation>().Value = "some comment";
                comment.Write();
                Assert.IsNotNull(sub.First(x => x.Get<IMemberAnnotation>().Member.Name == "ID"));

            }
        }
        
        public class TestDut : Dut
        {
        }

        public class DutStep : TestStep
        {
            public Dut Dut { get; set; }
            public int Sleep { get; set; }
            public override void Run()
            {
                if(Sleep != 0)
                    TapThread.Sleep(Sleep);
                if (string.Compare("Some comment", Dut.Comment, true) != 0)
                    throw new InvalidOperationException();
                if (Dut.IsConnected == false)
                    throw new InvalidOperationException("Dut is closed!");
                UpgradeVerdict(Verdict.Pass);
            }
        }

        [Test]
        public void ErrorStackOverflow()
        {
            var repa = new RepeatStep();
            var repb = new RepeatStep();
            repa.TargetStep = repb;
            repb.TargetStep = repa;

            var error = repa.Error; // this could once throw a stackoverflow exception due to forwarded errors.


            Assert.IsTrue(string.IsNullOrWhiteSpace(error));
        }

        [Test]
        public void DeferSynchronizationManager()
        {
            using (var tm = new ThreadManager())
            {
                Stopwatch sw = Stopwatch.StartNew();
                int finalCount = 10000;
                var sem = new Semaphore(0, finalCount);
                int counter = 0;
                for (int i = 0; i < finalCount; i++)
                {
                    tm.Enqueue(new TapThread(TapThread.Current,() =>
                    {

                        //Thread.Sleep(10);
                        Interlocked.Increment(ref counter);
                        sem.Release();
                    }));
                }
                for (int i = 0; i < finalCount; i++)
                {
                    sem.WaitOne();
                }
                
                Assert.AreEqual(finalCount, counter);
                var elapsed = sw.Elapsed;
                Debug.WriteLine("{0}", elapsed.TotalMilliseconds);
            }
        }

        /// <summary>
        /// This test proves that each WorkQueue can process things in sequence, while working in parallel.
        /// </summary>
        [Test]
        public void DeferSynchronization()
        {
            int testCount = 1000;
            
            var tw = new WorkQueue(WorkQueue.Options.None, "Test");
            var tw2 = new WorkQueue(WorkQueue.Options.None, "Test");
            int counter = 0;
            int counter2 = 0;
            var sem = new SemaphoreSlim(0);
            var sem2a = new SemaphoreSlim(0);
            var sem2b = new SemaphoreSlim(0);
            
            // enqueue a bunch of work.
            for (int i = 0; i < testCount; i++)
            {
                tw.EnqueueWork(() =>
                {
                    sem2a.Wait();
                    counter += 1;
                    sem.Release();
                });
                tw2.EnqueueWork(() =>
                {
                    sem2b.Wait();
                    counter2 += 1;
                    sem.Release();
                });
            }

            // Verify execution in parallel bit by bit (first half only).
            for (int i = 0; i < testCount / 2; i++)
            {
                sem2a.Release();
                sem2b.Release();
                for (int j = 0; j < 2; j++)
                {
                    if (!sem.Wait(TimeSpan.FromSeconds(10)))
                    {
                        throw new TimeoutException();
                    }
                }
                Assert.AreEqual(counter, i + 1);
                Assert.AreEqual(counter2, i + 1);
            }

            // second half, execute as fast as possible without locks.
            sem2a.Release(testCount / 2);
            sem2b.Release(testCount / 2);
            for(int i = 0; i < testCount/2; i++)
            {
                for (int j = 0; j < 2; j++)
                {
                    if (!sem.Wait(TimeSpan.FromSeconds(10)))
                    {
                        throw new TimeoutException();
                    }
                }
            }
            // verify it works at full speed.
            Assert.AreEqual(testCount, counter);
            Assert.AreEqual(testCount, counter2);
        }

        [Test]
        public void RunMassiveSynchronousPlan()
        {
            // run an excessively long test plan.

            int Count = 500;
            double maxDuration = 50;
            TestPlan plan = new TestPlan();
            TimeGuardStep guard = new TimeGuardStep() { Timeout = maxDuration, StopOnTimeout = true };
            plan.ChildTestSteps.Add(guard);
            for(int i = 0; i < Count; i++)
            {
                var seq1 = new SequenceStep();
                var verdict = new VerdictStep() { VerdictOutput = Verdict.Pass };
                seq1.ChildTestSteps.Add(verdict);
                guard.ChildTestSteps.Add(seq1);
            }
            var rl = new ResultListenerValidator();
            var result = plan.Execute(new[] { rl });
            Assert.AreEqual(Verdict.Pass, result.Verdict);
            Assert.IsNull(rl.Exception);
        }

        [Test]
        public void RunMassivelyParallelPlan()
        {
            

            // run an excessively long and parallel test plan.
            // since its parallel, this should go very fast still.
            int Count = 100; 
            double maxDuration = 50;

            TestPlan plan = new TestPlan();
            TimeGuardStep guard = new TimeGuardStep() { Timeout = maxDuration, StopOnTimeout = true };
            var parallel = new ParallelStep();
            plan.ChildTestSteps.Add(guard);
            guard.ChildTestSteps.Add(parallel);
            for (int i = 0; i < Count; i++)
            {
                var seq1 = new SequenceStep();
                var verdict = new VerdictStep() { VerdictOutput = Verdict.Pass }; // make sure the plan gets verdict 'Pass' if everything goes well.
                var delay = new DelayStep() { DelaySecs = 0.1 };
                seq1.ChildTestSteps.Add(verdict);
                seq1.ChildTestSteps.Add(delay);
                
                parallel.ChildTestSteps.Add(seq1);
            }
            
            for (int i = 0; i < 2; i++)
            {
                var rl = new ResultListenerValidator();
                var result = plan.Execute(new[] { rl });
                Assert.IsNull(rl.Exception);
                log.Debug(result.Duration, "Massively Parallel Plan");
                Assert.AreEqual(Verdict.Pass, result.Verdict);
            }
        }
        
        class DeferringStep : TestStep
        {
            public override void Run()
            {
                Results.Defer(() => { });
            }
        }
        
        [Test]
        public void RepeatRunDeferPlan()
        {
            var seq = new ParallelStep();
            for (int i = 0; i < 4; i++)
            {
                var def = new DeferringStep();
                seq.ChildTestSteps.Add(def);
            }

            var plan = new TestPlan();
            plan.ChildTestSteps.Add(seq);
            for (int i = 0; i < 100; i++)
            {
                var sem = new Semaphore(0, 1);
                var trd = TapThread.Start(() => { plan.Execute();
                    sem.Release();
                });

                if (!sem.WaitOne(100000))
                {
                    trd.Abort();
                    Assert.Fail("Deadlock occured in test plan");
                }
            }
        }

        class PlatformCheckResultListener : ResultListener
        {
            public bool TestPlanRunStarted;
            public string CommentWas;
            public string SerialWas;
            
            public override void OnTestPlanRunStart(TestPlanRun planRun)
            {
                CommentWas = planRun.Parameters["Comment", "DUT"]?.ToString();
                SerialWas = planRun.Parameters["Serial"]?.ToString();
                TestPlanRunStarted = true;
                base.OnTestPlanRunStart(planRun);
            }
        }

        class FcnUserInput : IUserInputInterface
        {
            public Action<object, TimeSpan, bool> F;

            public void RequestUserInput(object dataObject, TimeSpan Timeout, bool modal)
            {
                F(dataObject, Timeout, modal);
            }
        }


        [Test]
        [Pairwise]
        public void PlatformInteractionRace([Values(true,false)] bool runOpen,[Values(true, false)] bool lazy)
        {
            // things needs to happen in the right order.
            // PlatformInteraction should happen before anything on the ResultListener is called, except Open/Close.
            string expectedComment = "Some comment";
            var listener = new PlatformCheckResultListener();
            int requestCount = 0;
            bool failure = false;

            void waitFormInput(object obj, TimeSpan timeout, bool modal)
            {
                Assert.IsFalse(listener.TestPlanRunStarted);
                Thread.Sleep(20); // a short sleep to make sure that the error would appear.
                var mpo = obj as MetadataPromptObject;
                foreach(var dut in mpo.Resources.OfType<DummyDut>())
                {
                    dut.Comment = expectedComment;
                }
                requestCount += 1;
            }

            UserInput.SetInterface(new FcnUserInput { F = waitFormInput });

            bool prevWait = EngineSettings.Current.PromptForMetaData;
            EngineSettings.Current.PromptForMetaData = true;
            var prevManager = EngineSettings.Current.ResourceManagerType;
            if (lazy)
            {
                EngineSettings.Current.ResourceManagerType = new LazyResourceManager();
            }
            else
            {
                EngineSettings.Current.ResourceManagerType = new ResourceTaskManager();
            }
            
            try
            {
                DummyDut dut1 = new DummyDut() {Comment = "Comment0", ID = "ID0"};
                DutSettings.Current.Clear();
                DutSettings.Current.Add(dut1);
                TestPlan plan = new TestPlan();
                DutStep step = new DutStep();
                step.Dut = dut1;
                plan.ChildTestSteps.Add(step);
                if (runOpen)
                    plan.Open();
                try
                {
                    var run = plan.Execute(new[] { listener });
                    Assert.AreEqual(Verdict.Pass, run.Verdict);
                }
                finally
                {
                    if (runOpen)
                        plan.Close();
                }
            }
            finally
            {
                
                EngineSettings.Current.PromptForMetaData = prevWait;
                UserInput.SetInterface(null);
                EngineSettings.Current.ResourceManagerType = prevManager;
            }

            Assert.IsFalse(failure);
            Assert.AreEqual(1, requestCount);
            Assert.AreEqual(expectedComment, listener.CommentWas);
            if(!lazy)
                Assert.AreEqual(DummyDut.SerialNumber, listener.SerialWas);
        }

        [Test]
        [Ignore("Reenable when the resource manager supports multiple test plans")]
        public void TryMultipleRunsWithResources()
        {
            DummyDut dut1 = new DummyDut() { Comment = "Some comment" };
            DutSettings.Current.Clear();
            DutSettings.Current.Add(dut1);
            var sw = Stopwatch.StartNew();
            List<TapThread> lst = new List<TapThread>();
            List<TestPlanRun> runs = new List<TestPlanRun>();
            int maxcount = 2;
            Semaphore sem = new Semaphore(0, maxcount);
            for (int i = 0; i < maxcount; i++)
            {
                int cnt2 = 2;
                TestPlan plan = new TestPlan();
                for (int j = 0; j < cnt2; j++)
                {
                    DutStep step = new DutStep()
                    {
                        Dut = dut1,
                        Sleep = i * 5
                    };
                    plan.ChildTestSteps.Add(step);
                }
                lst.Add(TapThread.Start(() =>
                {
                    var run = plan.Execute();

                    Assert.AreEqual(cnt2, run.StepsWithPrePlanRun.Count);
                    lock (runs)
                        runs.Add(run);
                    sem.Release();
                }));
            }

            for (int i = 0; i < maxcount; i++)
                sem.WaitOne();
            var elaps = sw.Elapsed;
            Debug.WriteLine("Elapsed: {0}", elaps.TotalMilliseconds);
            foreach (var run in runs)
            {
                Assert.AreEqual(Verdict.Pass, run.Verdict);
            }
            


        }

        static TraceSource log = Log.CreateSource("test");

        private class TestPlanResultListener : IResultListener
        {
            private EventWaitHandle eventWaitHandle = null;

            public string Name { get; set; } = "ResultListener1";

            public bool IsConnected { get; private set; }

            // instead of #pragma warning disable/restore CS0067 SuppressMessageAttribute can be used
#pragma warning disable CS0067
            public event PropertyChangedEventHandler PropertyChanged;
#pragma warning restore CS0067

            public TestPlanResultListener(EventWaitHandle eventWaitHandle)
            {
                this.eventWaitHandle = eventWaitHandle;
            }

            public void Close()
            {
                IsConnected = false;
            }

            public void OnResultPublished(Guid stepRunID, ResultTable result)
            {
            }

            public void OnTestPlanRunCompleted(TestPlanRun planRun, Stream logStream)
            {
            }

            public void OnTestPlanRunStart(TestPlanRun planRun)
            {
                eventWaitHandle.Set();
            }

            public void OnTestStepRunCompleted(TestStepRun stepRun)
            {
            }

            public void OnTestStepRunStart(TestStepRun stepRun)
            {
            }

            public void Open()
            {
                IsConnected = true;
            }
        }

        [Test]
        public void TestSleepOneTestPlan()
        {
            //---------------------------------------------------------------------------------------------------------
            EventWaitHandle ewhPlan1IsRunning = new EventWaitHandle(false, EventResetMode.AutoReset);
            EventWaitHandle ewhPlan1StoppedRunning = new EventWaitHandle(false, EventResetMode.AutoReset);

            TestPlan plan1 = new TestPlan();
            var plan1Step1 = new DelayStep() { DelaySecs = 10.0 };
            var plan1Step2 = new DelayStep() { DelaySecs = 10.0 };
            plan1.ChildTestSteps.Add(plan1Step1);
            plan1.ChildTestSteps.Add(plan1Step2);
            
            //---------------------------------------------------------------------------------------------------------
            EventWaitHandle ewhPlan2IsRunning = new EventWaitHandle(false, EventResetMode.AutoReset);
            EventWaitHandle ewhPlan2StoppedRunning = new EventWaitHandle(false, EventResetMode.AutoReset);

            TestPlan plan2 = new TestPlan();
            var plan2Step1 = new DelayStep() { DelaySecs = 10.0 };
            var plan2Step2 = new DelayStep() { DelaySecs = 10.0 };
            var plan2Step3 = new DelayStep() { DelaySecs = 10.0 };
            plan2.ChildTestSteps.Add(plan2Step1);
            plan2.ChildTestSteps.Add(plan2Step2);
            plan2.ChildTestSteps.Add(plan2Step3);            
            
            //---------------------------------------------------------------------------------------------------------
            var tapThread1 = TapThread.Start(() =>
            {
                try
                {
                    plan1.Execute(new IResultListener[] {new TestPlanResultListener(ewhPlan1IsRunning)}, null,
                        new HashSet<ITestStep>(plan1.ChildTestSteps));
                }
                finally
                {
                    //TestPlan.Current is null after the TestPlan starts running
                    ewhPlan1StoppedRunning.Set();
                }
            });

            //---------------------------------------------------------------------------------------------------------            
            var tapThread2= TapThread.Start(() =>
            {
                try
                {
                    plan2.Execute(new IResultListener[] {new TestPlanResultListener(ewhPlan2IsRunning)}, null,
                        new HashSet<ITestStep>(plan2.ChildTestSteps));
                }
                finally
                {
                    ewhPlan2StoppedRunning.Set();
                }
            });

            if(!WaitHandle.WaitAll(new WaitHandle[] { ewhPlan1IsRunning, ewhPlan2IsRunning }, 120000))
                Assert.Fail("Test plan running timed out.");
            
            Assert.AreEqual(2, plan1.ChildTestSteps.Count);
            Assert.AreEqual(false, tapThread1.AbortToken.IsCancellationRequested);
            Assert.AreEqual(true, plan1.IsRunning, "1 Running");

            Assert.AreEqual(3, plan2.ChildTestSteps.Count);
            Assert.AreEqual(false, tapThread2.AbortToken.IsCancellationRequested);
            Assert.AreEqual(true, plan2.IsRunning, "2 Running");


            tapThread1.Abort();
            Assert.AreEqual(true, tapThread1.AbortToken.IsCancellationRequested, "Abort 1.1");
            Assert.AreEqual(false, tapThread2.AbortToken.IsCancellationRequested, "Abort 1.2");

            tapThread2.Abort();
            Assert.AreEqual(true, tapThread1.AbortToken.IsCancellationRequested, "Abort 2.1");
            Assert.AreEqual(true, tapThread2.AbortToken.IsCancellationRequested, "Abort 2.2");

            WaitHandle.WaitAll(new WaitHandle[] { ewhPlan1StoppedRunning, ewhPlan2StoppedRunning });

            Assert.AreEqual(false, plan1.IsRunning, "1 Running");
            Assert.AreEqual(false, plan2.IsRunning, "2 Running");
        }

        [Test]
        public void DuplicateStepInPlan()
        {
            var plan = new TestPlan();
            plan.ChildTestSteps.Add(new SequenceStep());
            try
            {
                plan.ChildTestSteps.Add(plan.ChildTestSteps[0]);
                Assert.Fail("This should have failed");
            }
            catch(InvalidOperationException)
            {

            }

            Assert.AreEqual(1, plan.ChildTestSteps.Count);

            var startId = plan.ChildTestSteps[0].Id;
            var seq2 = new SequenceStep() { Id = startId };
            plan.ChildTestSteps.Add(seq2);
            Assert.AreNotEqual(startId, seq2.Id);
            Assert.AreEqual(plan.ChildTestSteps[0].Id, startId);

        }

        [Test]
        public void TestPlanDeserializeError()
        {
            var listener = new TestTraceListener();
            var dut = new DummyDut() {Name = "DUT_TEST"};
            try
            {
                var plan = new TestPlan();
                var step = new DutStep();
                DutSettings.Current.Add(dut);
                step.Dut = dut;
                plan.Steps.Add(step);
                using (var buffer = new MemoryStream())
                {
                    plan.Save(buffer);
                    buffer.Seek(0, SeekOrigin.Begin);
                    var str = Encoding.UTF8.GetString(buffer.ToArray());
                    DutSettings.Current.Remove(dut);
                    Log.AddListener(listener);
                    var serializer = new TapSerializer();
                    serializer.Deserialize(buffer);
                }

                Log.Flush();
                // there should be an error message
                // since the DUT was not available for de-serialization.
                Assert.IsTrue(listener.ErrorMessage.Count > 0);
                
            }
            finally
            {
                Log.RemoveListener(listener);
                DutSettings.Current.Remove(dut);
            }
        }

        [Test]
        public void DefaultPlanMetadata()
        {
            PlanRunCollectorListener pl1 = new PlanRunCollectorListener();
            var plan = new TestPlan();
            plan.ChildTestSteps.Add(new ManySettingsStep());
            var run = plan.Execute(new[] {pl1});
            
            var parameters = run.Parameters;
            Assert.IsNotNull(parameters.Find(("Station", "Operator")));
            Assert.IsNull(parameters.Find(("Allow Metadata Prompt", "Engine")));
            var stepParameters = pl1.StepRuns.FirstOrDefault().Parameters;
            Assert.IsNotNull(stepParameters.Find("A", ""));
            Assert.IsNotNull(stepParameters.Find("Verdict", ""));
            Assert.IsNotNull(stepParameters.Find("Duration", ""));
            Assert.IsNull(stepParameters.Find(nameof(ManySettingsStep.Id), "")); // Id is not saved as Parameter
            Assert.IsNotNull(run.TestPlanXml);
            Assert.IsNotNull(run.Hash);
        }

        [Test]
        public void CheckBasicPlanContents()
        {
            var plan = new TestPlan();
            plan.ChildTestSteps.Add(new SequenceStep());
            var planXml = plan.SerializeToString();
            Assert.IsFalse(planXml.Contains("AllowEditWhilePaused"));

        }

        class CheckTestPlanXmlListener : ResultListener
        {   
            public override void OnTestPlanRunStart(TestPlanRun planRun)
            {
                base.OnTestPlanRunStart(planRun);
                if (planRun.TestPlanXml == null)
                    throw new Exception("Test plan XML is null!!");
            }
        }

        [Test]
        public void TestLoadCacheAndRun([Values(true, false)] bool cacheXml)
        {
            // this unit test checks that the TestPlanRun.TestPlanXml is not null
            // depending on CacheXML=true.
            var plan = new TestPlan();
            plan.ChildTestSteps.Add(new LogStep());
            var memstr = new MemoryStream();
            plan.Save(memstr);
            memstr.Seek(0, SeekOrigin.Begin);
            plan = TestPlan.Load(memstr, "test", cacheXml);
            var run = plan.Execute(new []{new CheckTestPlanXmlListener()});
            Assert.AreEqual(Verdict.NotSet, run.Verdict);
        }
    }

    [TestFixture]
    public class ResourceManagementTests
    {
        [Test]
        public void ResourceManagementValidation()
        {
            var old = EngineSettings.Current.ResourceManagerType;
            try
            {
                EngineSettings.Current.ResourceManagerType = new ResourceManageValidator();

                var tp = new TestPlan();
                tp.Steps.Add(new ValidationStep());

                tp.Open();

                Assert.AreEqual(1, ResourceManageValidator.StageCounter[TestPlanExecutionStage.Open]);

                var run = tp.Execute();

                Assert.AreEqual(1, ResourceManageValidator.StageCounter[TestPlanExecutionStage.Open]);

                tp.Close();

                Assert.IsFalse(run.FailedToStart);
                Assert.AreEqual(Verdict.Pass, run.Verdict);

                foreach (var kvp in ResourceManageValidator.StageCounter)
                    if (kvp.Value != 0)
                        Assert.AreEqual(0, kvp.Value, "Stage counter for {0} should be 0 but is {1}", kvp.Key, kvp.Value);
            }
            finally
            {
                EngineSettings.Current.ResourceManagerType = old;
            }
        }

        public class ValidationStep : TestStep
        {
            public override void PrePlanRun()
            {
                Assert.AreEqual(1, ResourceManageValidator.StageCounter[TestPlanExecutionStage.Open]);
                Assert.AreEqual(1, ResourceManageValidator.StageCounter[TestPlanExecutionStage.Execute]);
                Assert.AreEqual(1, ResourceManageValidator.StageCounter[TestPlanExecutionStage.PrePlanRun]);
            }

            public override void Run()
            {
                Assert.AreEqual(1, ResourceManageValidator.StageCounter[TestPlanExecutionStage.Open]);
                Assert.AreEqual(1, ResourceManageValidator.StageCounter[TestPlanExecutionStage.Execute]);
                Assert.AreEqual(1, ResourceManageValidator.StageCounter[TestPlanExecutionStage.Run]);

                UpgradeVerdict(Verdict.Pass);
            }

            public override void PostPlanRun()
            {
                Assert.AreEqual(1, ResourceManageValidator.StageCounter[TestPlanExecutionStage.Open]);
                Assert.AreEqual(1, ResourceManageValidator.StageCounter[TestPlanExecutionStage.Execute]);
                Assert.AreEqual(1, ResourceManageValidator.StageCounter[TestPlanExecutionStage.PostPlanRun]);
            }
        }

        public class ResourceManageValidator : IResourceManager
        {
            public static Dictionary<TestPlanExecutionStage, int> StageCounter = new Dictionary<TestPlanExecutionStage, int>();

            public IEnumerable<IResource> Resources => StaticResources;

            public IEnumerable<IResource> StaticResources { get; set; }
            public List<ITestStep> EnabledSteps { get; set; }

            public event Action<IResource> ResourceOpened;

            public void BeginStep(TestPlanRun planRun, ITestStepParent item, TestPlanExecutionStage stage, CancellationToken cancellationToken)
            {
                if (!StageCounter.ContainsKey(stage)) StageCounter[stage] = 0;
                StageCounter[stage]++;
                if (stage == TestPlanExecutionStage.Execute)
                {
                    if (item is TestPlan testplan)
                    {
                        var resources = ResourceManagerUtils.GetResourceNodes(StaticResources.Cast<object>().Concat(EnabledSteps));
                        testplan.StartResourcePromptAsync(planRun, resources.Select(res => res.Resource));
                    }
                }
            }

            public void EndStep(ITestStepParent item, TestPlanExecutionStage stage)
            {
                StageCounter[stage]--;
            }

            public void WaitUntilAllResourcesOpened(CancellationToken cancellationToken)
            {
            }

            public void WaitUntilResourcesOpened(CancellationToken cancellationToken, params IResource[] targets)
            {
                if (ResourceOpened != null)
                    targets.ToList().ForEach(ResourceOpened);
            }
        }

        class CrashInstrument : Instrument
        {
            public bool OpenThrow { get; set; }
            public bool OpenWait { get; set; }
            public bool CloseThrow { get; set; }
            public bool ClosedDuringOpen { get; set; }
            bool isOpening;

            public bool CloseCalled { get; set; }
            public override void Open()
            {
                if (IsConnected)
                    throw new InvalidOperationException("Instrument already connected");
                base.Open();
                isOpening = true;
                try
                {
                    if (OpenWait)
                        Thread.Sleep(20);

                    if (OpenThrow)
                        throw new Exception("Intended failure");
                }
                finally
                {
                    isOpening = false;
                }    
            }
            
            public override void Close()
            {
                CloseCalled = true;
                if (isOpening)
                {
                    ClosedDuringOpen = true;
                    Assert.Fail("Close called before open done.");
                }

                if (CloseThrow)
                    throw new Exception("Intended failure");
            }
        }

        [Test]
        public void OpenCloseOrder()
        {
            var instrA = new CrashInstrument {OpenThrow = true, CloseThrow = true, Name= "A"};
            var instrB = new CrashInstrument {OpenWait = true, Name= "B"};
            var parallel = new ParallelStep();
            // create a bunch of steps to make sure that we test race conditions
            // in the resource managers.
            for (int i = 0; i < 10; i++)
            {
                var stepA = new InstrumentTestStep { Instrument = instrA };
                var stepB = new InstrumentTestStep { Instrument = instrB };
                parallel.ChildTestSteps.Add(stepA);
                parallel.ChildTestSteps.Add(stepB);
            }
            
            var plan = new TestPlan();
            plan.Steps.Add(parallel);
            
            var run = plan.Execute();
            Assert.AreEqual(Verdict.Error, run.Verdict);
            Assert.IsFalse(instrA.ClosedDuringOpen);
            Assert.IsFalse(instrB.ClosedDuringOpen); 
            
            // close has to be called even though Open failed.
            Assert.IsTrue(instrA.CloseCalled, "instrA.ClosedCalled == false");
            Assert.IsTrue(instrB.CloseCalled, "instrB.ClosedCalled == false"); 
        }
        
        [Test]
        public void OpenCloseOrderSmall()
        {
            var instrA = new CrashInstrument {OpenThrow = true, CloseThrow = true, Name= "A"};
            
            var parallel = new ParallelStep();
            for (int i = 0; i < 10; i++)
                parallel.ChildTestSteps.Add(new InstrumentTestStep { Instrument = instrA });
            
            var plan = new TestPlan();
            plan.Steps.Add(parallel);
            
            var run = plan.Execute();
            Assert.AreEqual(Verdict.Error, run.Verdict);
            Assert.IsFalse(instrA.ClosedDuringOpen);
            
            // close has to be called even though Open failed.
            Assert.IsTrue(instrA.CloseCalled, "instrA.ClosedCalled == false");
        }
        

        [Test]
        public void TestFastTapThreads()
        {
            using (TapThread.UsingThreadContext())
            {
                var startThread = TapThread.Current;
                long startedThreads = 0;
                var sem = new Semaphore(0, 100);
                void newThread()
                {
                    Interlocked.Increment(ref startedThreads);
                    TapThread.Start(() =>
                    {
                        try
                        {
                            if (TapThread.Current.AbortToken.IsCancellationRequested)
                                return;
                            if (startedThreads >= 100)
                                startThread.Abort("end");
                            newThread();
                        }
                        finally
                        {
                            sem.Release();
                        }
                    });
                }
                newThread();
                for (long i = 0; i < startedThreads; i++)
                    sem.WaitOne();
            }
        }
        
        [Test]
        public void TestFastTapThreadsWaitWait()
        {
            using (TapThread.UsingThreadContext())
            {
                int concurrentThreads = 20;
                var evt = new ManualResetEvent(false);
                long startedThreads = 0;
                var sem = new Semaphore(0,concurrentThreads);
                void newThread()
                {
                    TapThread.Start(() =>
                    {
                        if (Interlocked.Increment(ref startedThreads) == concurrentThreads)
                            evt.Set();
                        
                        try
                        {
                            evt.WaitOne();
                            TapThread.Sleep(10);
                        }
                        finally
                        {
                            sem.Release();
                        }
                    });
                }

                for (int i = 0; i < concurrentThreads; i++)
                    newThread();
                for (long i = 0; i < concurrentThreads; i++)
                    sem.WaitOne();
            }
        }
        
        [Test]
        [Repeat(10)]
        public void OpenCloseOrderLazyRM()
        {
            var lastrm = EngineSettings.Current.ResourceManagerType;
            EngineSettings.Current.ResourceManagerType = new LazyResourceManager();
            try
            {
                OpenCloseOrder();
            }
            finally
            {
                EngineSettings.Current.ResourceManagerType = lastrm;
            }
        }
        
        [Test]
        [Repeat(10)]
        public void OpenCloseOrderLazyRM_Reduced()
        {
            var lastrm = EngineSettings.Current.ResourceManagerType;
            EngineSettings.Current.ResourceManagerType = new LazyResourceManager();
            try
            {
                OpenCloseOrderSmall();
            }
            finally
            {
                EngineSettings.Current.ResourceManagerType = lastrm;
            }
        }
        
        private class DeferredResultsStep : TestStep
        {
            public bool DeferredDone;
            public bool FailedDeferExecuted;
            public override void Run()
            {
                DeferredDone = false;
                FailedDeferExecuted = false;
                var sem = new Semaphore(0, 1);
                Results.Defer(() =>
                {
                    sem.WaitOne();
                    DeferredDone = true;
                    Log.Info("Deferred Step also done");
                });

                TapThread.Start(() =>
                {
                    try
                    {
                        Results.Defer(() =>
                        {
                            // this should fail.
                            Log.Error("This should never be called!!!");
                        });
                        FailedDeferExecuted = false;
                    }
                    catch
                    {
                        FailedDeferExecuted = true;
                    }

                    sem.Release();
                });
            }
        }

        [Test]
        public void TestDeferResultsStepInParallel()
        {
            var plan = new TestPlan();
            var parallel = new ParallelStep();
            var defer = new DeferredResultsStep();
            plan.Steps.Add(parallel);
            parallel.ChildTestSteps.Add(defer);
            plan.Execute();
            Assert.IsTrue(defer.DeferredDone);
            Assert.IsTrue(defer.FailedDeferExecuted);
        }

        private class DeferredResultsStep2 : TestStep
        {
            public ManualResetEvent CompleteDefer = new ManualResetEvent(false);
            public ManualResetEvent DeferStarted = new ManualResetEvent(false);
            public ManualResetEvent RunCompleted = new ManualResetEvent(false);
            public override void Run()
            {
                Results.Defer(() =>
                {
                    DeferStarted.Set();
                    CompleteDefer.WaitOne();
                    Log.Info("Deferred Step also done");
                });
                RunCompleted.Set();
            }
        }

        [Test]
        public void TestExecuteWaitForDefer_Simpler()
        {
            var plan = new TestPlan();
            var defer = new DeferredResultsStep2();
            plan.Steps.Add(defer);
            Task<TestPlanRun> t = Task.Run(() => plan.Execute());
            defer.CompleteDefer.Set();
            Assert.IsTrue(t.Wait(100000));
        }

        [Test]
        public void TestExecuteWaitForDefer_Simple()
        {
            var plan = new TestPlan();
            var defer = new DeferredResultsStep2();
            plan.Steps.Add(defer);
            Task<TestPlanRun> t = Task.Run(() => plan.Execute());
            defer.RunCompleted.WaitOne();
            defer.DeferStarted.WaitOne();
            // do something that takes about the time for a test plan to complete
            TestExecuteWaitForDefer_WithParallel_Simpler(); 
            
            Assert.IsFalse(t.IsCompleted);
            defer.CompleteDefer.Set();
            Assert.IsTrue(t.Wait(100000));
        }

        [Test]
        public void TestExecuteWaitForDefer_WithParallel_Simpler()
        {
            var plan = new TestPlan();
            var parallel = new ParallelStep();
            var defer = new DeferredResultsStep2();
            plan.Steps.Add(parallel);
            parallel.ChildTestSteps.Add(defer);
            Task<TestPlanRun> t = Task.Run(() => plan.Execute());
            defer.CompleteDefer.Set();
            Assert.IsTrue(t.Wait(100000));
        }
        
        [Test]
        public void TestExecuteWaitForDefer_WithParallel()
        {
            var plan = new TestPlan();
            var parallel = new ParallelStep();
            var defer = new DeferredResultsStep2();
            plan.Steps.Add(parallel);
            parallel.ChildTestSteps.Add(defer);
            Task<TestPlanRun> t = Task.Run(() => plan.Execute());
            defer.DeferStarted.WaitOne();
            defer.RunCompleted.WaitOne();
            
            // do something that takes about the time for a test plan to complete
            TestExecuteWaitForDefer_WithParallel_Simpler();
            
            Assert.IsFalse(t.IsCompleted);
            defer.CompleteDefer.Set();
            
            Assert.IsTrue(t.Wait(100000));
        }
        
        [Test]
        public void TestBreakOnPlanCompleted()
        {
            var rl = new resultListenerCrash() {CrashResultPhase = resultListenerCrash.ResultPhase.PlanRunCompleted};
            var plan = new TestPlan();
            var step = new SequenceStep();
            plan.ChildTestSteps.Add(step);
            var run = plan.Execute(new IResultListener[] {rl});
            Assert.AreEqual(Verdict.Error, run.Verdict);
        }
    }

    public class TestITestStep : ValidatingObject, ITestStep
    {

        public IInstrument Instrument { get; set; }

        public TestITestStep()
        {
            Name = "";
            Enabled = true;
        }

        TestStepList list = new TestStepList();

        public TestStepList ChildTestSteps
        {
            get { return list; }
        }

        public bool Enabled { get; set; }
            
        public Guid Id
        {
            get;set;
        }

        public bool IsReadOnly { get; set; }
        public string Name { get; set; }

        // Should cause StackOverflowException in serializer unless cycles are detected.
        //[System.Xml.Serialization.XmlIgnore]
        public ITestStepParent Parent { get; set; } 

        [System.Xml.Serialization.XmlIgnore]
        public TestPlanRun PlanRun { get; set; }

        [System.Xml.Serialization.XmlIgnore]
        public TestStepRun StepRun { get; set; }

        [System.Xml.Serialization.XmlIgnore]
        public string TypeName
        {
            get { return GetType().GetDisplayAttribute().GetFullName(); }
        }

        [System.Xml.Serialization.XmlIgnore]
        public Verdict Verdict { get; set; }
            
        public void PostPlanRun()
        {
                
        }

        public void PrePlanRun()
        {
                
        }
        public bool WasRun = false;
        public void Run()
        {
            WasRun = true;
            if(Instrument.IsConnected == false)
            {
                throw new InvalidOperationException("Instrument should be open");
            }
        }
    }

    /// <summary>
    /// Device to test run resultlistener run conformance.
    /// </summary>
    
    class ResultOrderTester : ResultListener, IExecutionListener
    {
        TestPlanRun currentPlanRun = null;
        readonly HashSet<Guid> currentStepRun = new HashSet<Guid>();
        public bool PlanRunCompletedRan = false;
        public bool StepRunCompletedRan = false;

        List<Exception> errors = new List<Exception>();
        public IEnumerable<Exception> Errors => errors.AsEnumerable();

        void Assert(bool condition)
        {
            if (!condition)
            {
                var err = new InvalidOperationException("Assert failed");
                errors.Add(err);
                throw err;
            }
        }

        public override void Open()
        {
            Assert(IsConnected == false);
            base.Open();
                
        }

        public override void Close()
        {
            Assert(IsConnected);
            base.Close();
        }

        public override void OnTestPlanRunStart(TestPlanRun planRun)
        {
            Assert(IsConnected);
            Assert(currentPlanRun == null);
            Assert(currentStepRun.Count == 0);
            currentPlanRun = planRun;
        }

        public override void OnTestPlanRunCompleted(TestPlanRun planRun, Stream logStream)
        {
            Assert(IsConnected);
            Assert(currentPlanRun != null);
            Assert(currentStepRun.Count == 0);
            Assert(currentPlanRun.Id == planRun.Id);
            currentPlanRun = null;
            PlanRunCompletedRan = true;
        }
        
        public override void OnTestStepRunStart(TestStepRun stepRun)
        {
            Assert(IsConnected);
            Assert(currentPlanRun != null);
            Assert(currentStepRun.Contains(stepRun.Id) == false);
            currentStepRun.Add(stepRun.Id);
        }
        public override void OnTestStepRunCompleted(TestStepRun stepRun)
        {
            Assert(IsConnected);
            Assert(currentPlanRun != null);
            Assert(currentStepRun.Contains(stepRun.Id));
            currentStepRun.Remove(stepRun.Id);
            StepRunCompletedRan = true;
        }

        public override void OnResultPublished(Guid stepRunid, ResultTable result)
        {
            Assert(IsConnected);
            Assert(currentStepRun.Contains(stepRunid));
            Assert(currentPlanRun != null);
        }

        public void OnTestStepExecutionChanged(Guid stepId, TestStepRun stepRun, StepState newState, long changeTime)
        {
            Assert(IsConnected);
            switch (newState)
            {
                case StepState.Idle:
                    break;
                case StepState.PrePlanRun:
                    break;
                case StepState.Running:
                    break;
                case StepState.Deferred:
                    break;
                case StepState.PostPlanRun:
                    break;
            }
        }
    }

    /// <summary>
    /// A steps that uses a thread 100%.
    /// </summary>
    public class BusyStep : TestStep
    {
        [System.ComponentModel.Description("How many seconds to hog the thread.")]
        public double Seconds { get; set; }
        public override void Run()
        {
            var sw = Stopwatch.StartNew();
            while (sw.Elapsed.TotalSeconds < Seconds) { }
        }
    }

    /// <summary>
    /// A SCPI instrument that can connect to any instrument. Use with the SCPI step.
    /// </summary>
    public class ScpiDummyInstrument : ScpiInstrument
    {
        /// <summary>
        /// Tag for identifying the dummy instrument.
        /// </summary>
        public string Tag { get; set; }
    }

    /// <summary>
    /// A steps that sends a single scpi command or query to the instrument. If query it waits for the response.
    /// </summary>
    public class ScpiTestStep : TestStep
    {
        public string Command { get; set; }
        public ScpiInstrument Instrument { get; set; }

        public override void Run()
        {
            if (Command.Contains("?"))
            {
                Instrument.ScpiQuery(Command);
            }
            else
            {
                Instrument.ScpiCommand(Command);
            }
        }

    }

    public class RegexStepTest : RegexOutputStep
    {
        public override bool GeneratesOutput 
        {
            get { return true; }
        }

        public override void Run()
        {
            {
                var Result = "1 2 3";
                this.RegularExpressionPattern = new Enabled<string> { Value = "([1-9])\\s([1-9])\\s([1-9])", IsEnabled = true };
                ProcessOutput(Result);
                Assert.AreEqual(Verdict.Pass, Verdict);
                Verdict = Verdict.NotSet;
            }

            {
                var Result = "dkwaud029jad9aABCjd2;9quwaj;d";
                this.RegularExpressionPattern = new Enabled<string> { Value = ".*(ABC).*", IsEnabled = true };
                ProcessOutput(Result);
                Assert.AreEqual(Verdict.Pass, Verdict);
                Verdict = Verdict.NotSet;
            }
            {
                var Result = "dkwaud029jad9aABjd2;9quwaj;d";
                this.RegularExpressionPattern = new Enabled<string> { Value = ".*(ABC).*", IsEnabled = true };
                ProcessOutput(Result);
                Assert.AreEqual(Verdict.Fail, Verdict);
                Verdict = Verdict.NotSet;
            }
            Verdict = Verdict.Pass;
        }
    }

    [TestFixture]
    public class RegexStepTester
    {

        [Test]
        public void DoRegexStepTest()
        {
            var regexStep = new RegexStepTest();
            TestPlan plan = new TestPlan();
            plan.ChildTestSteps.Add(regexStep);
            var run = plan.Execute();
            Assert.AreEqual(Verdict.Pass, run.Verdict);
        }
    }

    public class ManySettingsStep : TestStep
    {
        public int A { get; set; } = 123;
        public int[] B { get; set; } = new[] {1, 2, 3};
        public Instrument[] C { get; set; } = Array.Empty<Instrument>();
        public Instrument[] D { get; set; }= Array.Empty<Instrument>();
        public Instrument[] E { get; set; }= Array.Empty<Instrument>();
        public string F { get; set; } = "Hello world!!";
        
        [EnabledIf(nameof(A), 123)]
        public Enabled<string> G { get; set; } = new Enabled<string>() {Value = "Hello"};
        [EnabledIf(nameof(A), 123)]
        public List<string> H { get; set; } = new List<string>{"1 2 3"};
        [EnabledIf(nameof(A), 123)]
        public Enabled<double> I { get; set; } = new Enabled<double>();
        [EnabledIf(nameof(A), 123)]
        public ITestStep Step { get; set; }
        
        public override void Run()
        {
            
        }
    }
}