// 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 System;
|
using System.Linq;
|
using System.Threading.Tasks;
|
using NUnit.Framework;
|
using OpenTap.Plugins.BasicSteps;
|
|
namespace OpenTap.Engine.UnitTests
|
{
|
[TestFixture]
|
public class TestPlanBreakRequestedTests
|
{
|
|
[AllowAnyChild]
|
public class WithEvents : TestStep
|
{
|
public override void Run()
|
{
|
OfferBreak();
|
RunChildSteps();
|
}
|
}
|
|
|
private int _pausedDetectedCount;
|
private int _startingDetectedCount;
|
|
[Test]
|
public void RunFlatTestplan()
|
{
|
TestPlan testplan = new TestPlan();
|
WithEvents step1 = new WithEvents();
|
WithEvents step2 = new WithEvents();
|
WithEvents step3 = new WithEvents();
|
WithEvents step4 = new WithEvents();
|
|
testplan.Steps.Add(step1);
|
testplan.Steps.Add(step2);
|
testplan.Steps.Add(step3);
|
testplan.Steps.Add(step4);
|
|
testplan.BreakOffered += _testplan_TestStepPaused;
|
|
_pausedDetectedCount = 0;
|
_startingDetectedCount = 0;
|
|
testplan.Execute();
|
//Since the plan is flat, the starting and paused count is the same.
|
Assert.IsTrue(_startingDetectedCount == TotalEnabledStepsInTestPlan(testplan));
|
Assert.IsTrue(_pausedDetectedCount == TotalEnabledStepsInTestPlan(testplan));
|
}
|
|
|
private TestPlan testplanJumpToStep;
|
private bool firstBreak = true;
|
[Test]
|
public void BreakJumpToStepRunNull()
|
{
|
testplanJumpToStep = new TestPlan();
|
SequenceStep step1 = new SequenceStep();
|
SequenceStep step2 = new SequenceStep();
|
SequenceStep step3 = new SequenceStep();
|
|
testplanJumpToStep.Steps.Add(step1);
|
testplanJumpToStep.Steps.Add(step2);
|
testplanJumpToStep.Steps.Add(step3);
|
|
testplanJumpToStep.BreakOffered += Testplan_BreakOffered;
|
|
firstBreak = true;
|
testplanJumpToStep.Execute();
|
|
foreach (var step in testplanJumpToStep.Steps)
|
Assert.IsNull(step.StepRun);
|
}
|
|
private void Testplan_BreakOffered(object sender, BreakOfferedEventArgs e)
|
{
|
if (firstBreak)
|
{
|
e.JumpToStep = testplanJumpToStep.Steps.Last().Id;
|
firstBreak = false;
|
}
|
}
|
|
[Test]
|
[Repeat(2)]
|
public void BreakAbortStepRunNull()
|
{
|
TestPlan testPlan = new TestPlan();
|
SequenceStep step1 = new SequenceStep();
|
SequenceStep step2 = new SequenceStep();
|
SequenceStep step3 = new SequenceStep();
|
|
testPlan.Steps.Add(step1);
|
testPlan.Steps.Add(step2);
|
testPlan.Steps.Add(step3);
|
|
TapThread.WithNewContext(() =>
|
{
|
var planThread = TapThread.Current;
|
testPlan.BreakOffered += (s, e) => planThread.Abort();
|
testPlan.Execute();
|
Assert.IsTrue(TapThread.Current.AbortToken.IsCancellationRequested);
|
});
|
Assert.IsFalse(TapThread.Current.AbortToken.IsCancellationRequested);
|
|
foreach (var step in testPlan.Steps)
|
Assert.IsNull(step.StepRun);
|
}
|
|
static ThreadHierarchyLocal<object> tapThreadLocalObject = new ThreadHierarchyLocal<object>();
|
[Test]
|
public void HierarchyLocalWithThreads()
|
{
|
// This test verifies that ThreadHierarchyLocal work with different thread contexts.
|
//
|
tapThreadLocalObject.LocalValue = (int)5;
|
// At child thread level it should be 5.
|
TapThread.WithNewContext(() => Assert.AreEqual(5, (int)tapThreadLocalObject.LocalValue));
|
TapThread.WithNewContext(() =>
|
{
|
tapThreadLocalObject.LocalValue = (int)6;
|
// At child-child thread level it should be 6.
|
TapThread.WithNewContext(() => Assert.AreEqual(6, (int)tapThreadLocalObject.LocalValue));
|
});
|
|
// At this level it should still be 5.
|
TapThread.WithNewContext(() => Assert.AreEqual(5, (int)tapThreadLocalObject.LocalValue));
|
|
// for no parent it should not have been set.
|
TapThread.WithNewContext(() => Assert.IsNull(tapThreadLocalObject.LocalValue), parent: null);
|
}
|
|
[Test]
|
public void RunHierarchical()
|
{
|
TestPlan testplan = new TestPlan();
|
|
var grandParent = new WithEvents();
|
testplan.Steps.Add(grandParent);
|
|
var parent = new WithEvents();
|
grandParent.ChildTestSteps.Add(parent);
|
|
var child1 = new WithEvents();
|
parent.ChildTestSteps.Add(child1);
|
|
var child2 = new WithEvents();
|
parent.ChildTestSteps.Add(child2);
|
|
testplan.BreakOffered += _testplan_TestStepPaused;
|
|
_pausedDetectedCount = 0;
|
_startingDetectedCount = 0;
|
|
testplan.Execute();
|
|
// Since ALL the steps are of type WithEvents, we continue to get
|
// a pausedcount = startingCount = totalcount.
|
Assert.IsTrue(_startingDetectedCount == TotalEnabledStepsInTestPlan(testplan));
|
Assert.IsTrue(_pausedDetectedCount == TotalEnabledStepsInTestPlan(testplan));
|
}
|
|
[Test]
|
public void RunHierarchical2()
|
{
|
TestPlan testplan = new TestPlan();
|
|
var grandParent = new SequenceStep();
|
testplan.Steps.Add(grandParent);
|
|
var parent = new SequenceStep();
|
grandParent.ChildTestSteps.Add(parent);
|
|
var child1 = new WithEvents();
|
parent.ChildTestSteps.Add(child1);
|
|
var child2 = new WithEvents();
|
parent.ChildTestSteps.Add(child2);
|
|
testplan.BreakOffered += _testplan_TestStepPaused;
|
|
_pausedDetectedCount = 0;
|
_startingDetectedCount = 0;
|
|
testplan.Execute();
|
|
// Since only two of the steps are with events, we get
|
// _starting = total
|
// _pausedCount = 2;
|
var test = TotalEnabledStepsInTestPlan(testplan);
|
Assert.IsTrue(_startingDetectedCount == TotalEnabledStepsInTestPlan(testplan));
|
Assert.IsTrue(_pausedDetectedCount == 2);
|
}
|
|
|
[Test]
|
public void RunLoop()
|
{
|
TestPlan testplan = new TestPlan();
|
|
var grandParent = new RepeatStep();
|
uint loopCount = 7;
|
grandParent.Count = loopCount;
|
grandParent.Action = RepeatStep.RepeatStepAction.Fixed_Count;
|
testplan.Steps.Add(grandParent);
|
|
var parent = new WithEvents();
|
grandParent.ChildTestSteps.Add(parent);
|
|
testplan.BreakOffered += _testplan_TestStepPaused;
|
|
_pausedDetectedCount = 0;
|
_startingDetectedCount = 0;
|
|
testplan.Execute();
|
|
//We will actually have loopCount + 1 starts.
|
// We get a start for each of the loops around "withevents steps", plus one for the outer loop "FixedCountLoop" step
|
Assert.AreEqual(loopCount + 1, _startingDetectedCount, "StartingDetectedCount");
|
|
//Since fixed count loop does NOT have a pause, it will not count in the pause count.
|
Assert.AreEqual(loopCount, _pausedDetectedCount, "PausedDetectedCount");
|
}
|
|
void _testplan_TestStepPaused(object sender, BreakOfferedEventArgs e)
|
{
|
|
if (e.IsTestStepStarting)
|
_startingDetectedCount++;
|
else
|
_pausedDetectedCount++;
|
}
|
|
int TotalEnabledStepsInTestPlan(TestPlan testplan)
|
{
|
int total = testplan.EnabledSteps.Count;
|
foreach (ITestStep testStep in testplan.Steps)
|
{
|
total += testStep.RecursivelyGetChildSteps(TestStepSearch.EnabledOnly).Count();
|
}
|
return total;
|
}
|
|
[Test]
|
public void ParmsCheck()
|
{
|
TestPlan testplan = new TestPlan();
|
DelayStep step1 = new DelayStep();
|
string myName = "fred";
|
step1.Name = myName;
|
testplan.Steps.Add(step1);
|
|
testplan.BreakOffered += (s, e) =>
|
{
|
Assert.IsTrue(e.TestStepRun.Verdict == Verdict.NotSet);
|
//Assert.IsTrue(e.TestStepRun.Step.GetStepPath().Contains(myName));
|
};
|
testplan.Execute();
|
|
}
|
|
public class SetVerdictStep : TestStep
|
{
|
public Verdict SetVerdict { get; set; } = Verdict.NotSet;
|
|
public override void Run()
|
{
|
UpgradeVerdict(SetVerdict);
|
}
|
}
|
|
[TestCase(Verdict.Pass, Verdict.Pass)]
|
[TestCase(Verdict.Fail, Verdict.Fail)]
|
[TestCase(Verdict.Error, Verdict.Error)]
|
public void TestDeadlockInReferencedPlan(Verdict inputVerdict, Verdict expectedVerdict)
|
{
|
bool wrap = false;
|
// We construct this testplan:
|
// Top
|
// -- Outer Sequence
|
// ---- Inner Sequence
|
// ------ SetVerdictStep
|
// -- If Verdict(Inner Sequence)
|
|
var childPlan = new TestPlan();
|
var outerSequence2 = new SequenceStep();
|
childPlan.ChildTestSteps.Add(outerSequence2);
|
|
ITestStepParent outerSequence = wrap ? outerSequence2 : childPlan;
|
|
var innerSequence = new SequenceStep();
|
var setVerdictStep = new SetVerdictStep() { SetVerdict = inputVerdict };
|
outerSequence.ChildTestSteps.Add(innerSequence);
|
innerSequence.ChildTestSteps.Add(setVerdictStep);
|
|
BreakConditionProperty.SetBreakCondition(setVerdictStep, BreakCondition.BreakOnFail | BreakCondition.BreakOnError);
|
|
var ifStep = new IfStep
|
{
|
InputVerdict =
|
{
|
Step = innerSequence,
|
Property = TypeData.GetTypeData(innerSequence).GetMember(nameof(innerSequence.Verdict))
|
},
|
Action = IfStep.IfStepAction.RunChildren,
|
TargetVerdict = Verdict.Fail
|
};
|
outerSequence.ChildTestSteps.Add(ifStep);
|
|
var run = childPlan.ExecuteAsync();
|
Task.WaitAny(run, Task.Delay(TimeSpan.FromSeconds(1000)));
|
Assert.That(run.Wait(0), Is.True, "Testplan timed out");
|
Assert.That(run.Result.Verdict, Is.EqualTo(expectedVerdict));
|
}
|
}
|
}
|
