// 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.IO;
|
using System.Text;
|
using OpenTap.Plugins.BasicSteps;
|
using System;
|
using System.Linq;
|
using OpenTap.Plugins;
|
|
namespace OpenTap.Engine.UnitTests
|
{
|
public class MacroFilePathTestStep : TestStep
|
{
|
public MacroString PathToThing { get; set; }
|
|
public string ExpandedString { get; set; }
|
|
public MacroFilePathTestStep()
|
{
|
PathToThing = new MacroString(this);
|
ExpandedString = "";
|
}
|
|
public override void Run()
|
{
|
ExpandedString = PathToThing.Expand();
|
}
|
}
|
|
[TestFixture]
|
public class ExternalTestPlanParameterTest
|
{
|
[Test]
|
public void SetValuesTest()
|
{
|
var delayStep1 = new DelayStep();
|
var delayStep2 = new DelayStep();
|
var logStep = new LogStep();
|
var logStep2 = new LogStep();
|
var fileStep = new MacroFilePathTestStep();
|
var fileStep2 = new MacroFilePathTestStep();
|
var ifstep = new IfStep();
|
|
fileStep.PathToThing.Text = "<TESTPLANDIR>\\asdasd";
|
TestPlan plan = new TestPlan();
|
plan.ChildTestSteps.Add(delayStep1);
|
plan.ChildTestSteps.Add(delayStep2);
|
plan.ChildTestSteps.Add(logStep);
|
plan.ChildTestSteps.Add(logStep2);
|
plan.ChildTestSteps.Add(fileStep);
|
plan.ChildTestSteps.Add(fileStep2);
|
plan.ChildTestSteps.Add(ifstep);
|
ifstep.InputVerdict.Step = delayStep2;
|
ifstep.InputVerdict.Property = TypeData.GetTypeData(delayStep1).GetMember("Verdict");
|
var delayInfo = TypeData.GetTypeData(delayStep1);
|
var logInfo = TypeData.GetTypeData(logStep);
|
var fileStepInfo = TypeData.GetTypeData(fileStep);
|
plan.ExternalParameters.Add(delayStep1, delayInfo.GetMember("DelaySecs"));
|
plan.ExternalParameters.Add(delayStep2, delayInfo.GetMember("DelaySecs"), "Time Delay");
|
plan.ExternalParameters.Add(logStep, logInfo.GetMember("Severity"), Name: "Severity");
|
plan.ExternalParameters.Add(logStep2, logInfo.GetMember("Severity"), Name: "Severity");
|
plan.ExternalParameters.Add(fileStep, fileStepInfo.GetMember("PathToThing"), Name: "Path1");
|
plan.ExternalParameters.Add(fileStep2, fileStepInfo.GetMember("PathToThing"), Name: "Path1");
|
plan.ExternalParameters.Add(ifstep, TypeData.GetTypeData(ifstep).GetMember(nameof(IfStep.InputVerdict)), Name: "InputVerdict");
|
for (int j = 0; j < 5; j++)
|
{
|
for (double x = 0.01; x < 10; x += 3.14)
|
{
|
plan.ExternalParameters.Get("Time Delay").Value = x;
|
Assert.AreEqual(x, delayStep1.DelaySecs);
|
Assert.AreEqual(x, delayStep2.DelaySecs);
|
}
|
|
plan.ExternalParameters.Get("Severity").Value = LogSeverity.Error;
|
Assert.AreEqual(LogSeverity.Error, logStep.Severity);
|
Assert.AreEqual(LogSeverity.Error, logStep2.Severity);
|
|
plan.ExternalParameters.Get("Path1").Value = plan.ExternalParameters.Get("Path1").Value;
|
|
string planstr = null;
|
using (var memstream = new MemoryStream())
|
{
|
plan.Save(memstream);
|
planstr = Encoding.UTF8.GetString(memstream.ToArray());
|
}
|
Assert.IsTrue(planstr.Contains(@"Parameter=""Time Delay"""));
|
Assert.IsTrue(planstr.Contains(@"Parameter=""Severity"""));
|
Assert.IsTrue(planstr.Contains(@"Parameter=""Path1"""));
|
|
using (var memstream = new MemoryStream(Encoding.UTF8.GetBytes(planstr)))
|
plan = TestPlan.Load(memstream, planstr);
|
|
delayStep1 = (DelayStep)plan.ChildTestSteps[0];
|
delayStep2 = (DelayStep)plan.ChildTestSteps[1];
|
logStep = (LogStep)plan.ChildTestSteps[2];
|
logStep2 = (LogStep)plan.ChildTestSteps[3];
|
fileStep = (MacroFilePathTestStep)plan.ChildTestSteps[4];
|
fileStep2 = (MacroFilePathTestStep)plan.ChildTestSteps[5];
|
ifstep = (IfStep)plan.ChildTestSteps[6];
|
Assert.IsTrue(fileStep2.PathToThing.Context == fileStep2);
|
Assert.AreEqual(fileStep2.PathToThing.Text, fileStep.PathToThing.Text);
|
Assert.AreEqual(delayStep2, ifstep.InputVerdict.Step);
|
}
|
}
|
|
[Test]
|
public void SerializeDeserializeWithDutExternalParameter()
|
{
|
var plan = new TestPlan();
|
var step = new TestPlanTest.DutStep();
|
var dut1 = new DummyDut {Name = "DUT1"};
|
var dut2 = new DummyDut {Name = "DUT2"};
|
|
DutSettings.Current.Add(dut1);
|
DutSettings.Current.Add(dut2);
|
try
|
{
|
step.Dut = dut1;
|
plan.ChildTestSteps.Add(step);
|
plan.ExternalParameters.Add(step,
|
TypeData.GetTypeData(step).GetMember(nameof(TestPlanTest.DutStep.Dut)), "dut");
|
|
using (var memstr = new MemoryStream())
|
{
|
plan.Save(memstr);
|
|
var serializer = new TapSerializer();
|
var ext = serializer.GetSerializer<ExternalParameterSerializer>();
|
ext.PreloadedValues["dut"] = "DUT2";
|
|
memstr.Seek(0, SeekOrigin.Begin);
|
plan = (TestPlan)serializer.Deserialize(memstr);
|
}
|
|
step = (TestPlanTest.DutStep) plan.ChildTestSteps[0];
|
Assert.AreEqual(step.Dut, dut2);
|
}
|
finally
|
{
|
DutSettings.Current.Remove(dut1);
|
DutSettings.Current.Remove(dut2);
|
}
|
|
}
|
|
|
[Test]
|
public void TestParameterizedVerdictOf()
|
{
|
// Create the test plan
|
var plan = new TestPlan();
|
var seq = new SequenceStep();
|
var repeat = new RepeatStep();
|
plan.ChildTestSteps.Add(seq);
|
seq.ChildTestSteps.Add(repeat);
|
|
var a = AnnotationCollection.Annotate(repeat);
|
|
void VerifyAvailable(AnnotationCollection mem)
|
{
|
// Verify the expected available values for the member
|
var avail = mem.Get<IAvailableValuesAnnotation>().AvailableValues.Cast<object>().ToArray();
|
Assert.AreEqual(2, avail.Length);
|
Assert.IsTrue(avail.Contains(seq));
|
Assert.IsTrue(avail.Contains(repeat));
|
}
|
|
var mem = a.GetMember(nameof(repeat.TargetStep));
|
VerifyAvailable(mem);
|
|
{ // Parameterize the member on the parent step
|
var parameterize = mem.Get<MenuAnnotation>().MenuItems.FirstOrDefault(x =>
|
x.Get<IconAnnotationAttribute>()?.IconName == IconNames.ParameterizeOnParent);
|
parameterize.Get<IMethodAnnotation>().Invoke();
|
|
mem = AnnotationCollection.Annotate(seq).GetMember(@"Parameters \ Verdict Of");
|
VerifyAvailable(mem);
|
|
var unparameterize = mem.Get<MenuAnnotation>().MenuItems.FirstOrDefault(x =>
|
x.Get<IconAnnotationAttribute>()?.IconName == IconNames.Unparameterize);
|
unparameterize.Get<IMethodAnnotation>().Invoke();
|
}
|
|
{ // Parameterize the member on the test plan
|
var parameterize = mem.Get<MenuAnnotation>().MenuItems.FirstOrDefault(x =>
|
x.Get<IconAnnotationAttribute>()?.IconName == IconNames.ParameterizeOnTestPlan);
|
parameterize.Get<IMethodAnnotation>().Invoke();
|
|
mem = AnnotationCollection.Annotate(plan).GetMember(@"Parameters \ Verdict Of");
|
VerifyAvailable(mem);
|
}
|
}
|
|
private void GenerateTestPlanWithNDelaySteps(int stepsCount, string filePath, double defaultValue, string externalParameterName)
|
{
|
Assert.IsTrue(stepsCount > 0);
|
|
// Create a test plan with two DelaySteps.
|
// Each of the DelaySteps will expose a it's delay property as an external parameter.
|
TestPlan plan = new TestPlan();
|
|
for (int i = 0; i < stepsCount; i++)
|
{
|
var delayStep = new DelayStep { DelaySecs = defaultValue };
|
plan.ChildTestSteps.Add(delayStep);
|
var delayInfo = TypeData.GetTypeData(delayStep);
|
plan.ExternalParameters.Add(delayStep, delayInfo.GetMember("DelaySecs"), externalParameterName);
|
}
|
|
// Write the test plan to a file
|
plan.Save(filePath);
|
}
|
|
[Test]
|
public void SettingOfExternalParametersOnTestReferencePlan()
|
{
|
double defaultValue = 0.7; //seconds
|
double newValue = 7.0; //seconds
|
//double tolerance = Math.Abs(newValue * .0000001); // The tolerance for variation in their delay double values
|
int stepsCount = 20; // how many delay steps should be generated and tested
|
string externalParameterName = "External Delay";
|
string filePath = System.IO.Path.GetTempPath() + Guid.NewGuid().ToString() + ".TapPlan";
|
|
GenerateTestPlanWithNDelaySteps(stepsCount, filePath, defaultValue, externalParameterName);
|
|
try
|
{
|
// Create a test plan
|
TestPlan testPlan = new TestPlan();
|
|
// Create a ReferencePlanStep and add it to the test plan
|
TestPlanReference tpr = new TestPlanReference();
|
MacroString ms = new MacroString(tpr) { Text = filePath };
|
tpr.Filepath = ms; // automatically calls LoadTesPlan
|
testPlan.ChildTestSteps.Add(tpr);
|
|
Assert.AreEqual(1, testPlan.ChildTestSteps.Count);
|
Assert.AreEqual(stepsCount, tpr.ChildTestSteps.Count);
|
|
// ----------------------------------------------------------------------------------------------------
|
// This is how to get access to a TestPlanReference loaded test plan's children's external paramters:
|
ITypeData ti = TypeData.GetTypeData(tpr);
|
// IMemberInfo mi = ti.GetMember(externalParameterName); <- not possible to get property by its name in case the property name contains characters not valid of a C# property name
|
IMemberData mi = ti.GetMembers().FirstOrDefault(m => m.Attributes.Any(xa => (xa as IDisplayAnnotation)?.Name == externalParameterName)); // <- the right approach
|
// ----------------------------------------------------------------------------------------------------
|
|
Assert.IsNotNull(mi);
|
Assert.AreEqual(defaultValue, mi.GetValue(tpr));
|
mi.SetValue(tpr, newValue);
|
|
// Test that the new value has been set on all the inner delay steps
|
for (int i = 0; i < stepsCount; i++)
|
{
|
DelayStep delayStep = tpr.ChildTestSteps[i] as DelayStep;
|
Assert.IsNotNull(delayStep);
|
//Assert.IsTrue(Math.Abs(newValue - delayStep.DelaySecs) <= tolerance);
|
Assert.AreEqual(newValue, delayStep.DelaySecs);
|
}
|
}
|
finally
|
{
|
// delete the temporary file in the end
|
if(File.Exists(filePath))
|
{
|
File.Delete(filePath);
|
}
|
}
|
}
|
|
[Test]
|
public void SaveAndLoadTestPlanReference()
|
{
|
double defaultValue = 0.7; //seconds
|
//double tolerance = Math.Abs(newValue * .0000001); // The tolerance for variation in their delay double values
|
int stepsCount = 1; // how many delay steps should be generated and tested
|
string externalParameterName = "External Delay";
|
string externalParamaterNameEncoded = "External_x0020_Delay";
|
string externalParamaterNameLegacy = "prop0";
|
string filePath1 = System.IO.Path.GetTempPath() + Guid.NewGuid().ToString() + ".TapPlan";
|
string filePath2 = System.IO.Path.GetTempPath() + Guid.NewGuid().ToString() + ".TapPlan";
|
string filePath3 = System.IO.Path.GetTempPath() + Guid.NewGuid().ToString() + ".TapPlan";
|
|
try
|
{
|
// Save the test plan to be referenced
|
GenerateTestPlanWithNDelaySteps(stepsCount, filePath1, defaultValue, externalParameterName);
|
|
// Scope for separating the test Serialization (Save) from Deserialization (Load)
|
{
|
// Create a test plan
|
TestPlan testPlan = new TestPlan();
|
|
// Create a ReferencePlanStep and add it to the test plan
|
TestPlanReference tpr = new TestPlanReference();
|
MacroString ms = new MacroString(tpr) { Text = filePath1 };
|
tpr.Filepath = ms; // automatically calls LoadTesPlan
|
testPlan.ChildTestSteps.Add(tpr);
|
|
// Save the new test plan
|
testPlan.Save(filePath2);
|
|
// The output should be something like this, remark the "External Delay" has been encoded as "External_x0020_Delay"
|
//<?xml version=\"1.0\" encoding=\"utf-8\"?>
|
//<TestPlan type=\"OpenTap.TestPlan\" Locked=\"false\">
|
// <Steps>
|
// <TestStep type=\"ref@OpenTap.Plugins.BasicSteps.TestPlanReference\" Version=\"9.0.0-Development\" Id=\"ae56d9d6-e077-4524-bd14-cb0c9f2d4ced\">
|
// <External_x0020_Delay>0.7</External_x0020_Delay>
|
// <Filepath>%TEMP%\\e7563ab3-d5e2-4e27-bc77-1f9b76feb37c.TapPlan</Filepath>
|
// <StepMapping />
|
// <Enabled>true</Enabled>
|
// <Name>Test Plan Reference</Name>
|
// </TestStep>
|
// </Steps>
|
// <Package.Dependencies>
|
// <Package Name=\"OpenTAP\" Version=\"9.0.0+15a61e86\" />
|
// </Package.Dependencies>
|
//</TestPlan>
|
|
// Verify that the saved file contains the encoded elements
|
using (var str = File.Open(filePath2, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
|
{
|
using (var read = new StreamReader(str))
|
{
|
string content = read.ReadToEnd();
|
Assert.IsTrue(content.Contains($"<{externalParamaterNameEncoded}>"));
|
Assert.IsTrue(content.Contains($"</{externalParamaterNameEncoded}>"));
|
Assert.IsFalse(content.Contains($"<{externalParameterName}>"));
|
Assert.IsFalse(content.Contains($"</{externalParameterName}>"));
|
Assert.IsFalse(content.Contains($"<{externalParamaterNameLegacy}>"));
|
Assert.IsFalse(content.Contains($"</{externalParamaterNameLegacy}>"));
|
}
|
}
|
}
|
|
// Scope for separating the test Deserialization (Load) from Serialization (Save)
|
{
|
TestPlan testPlan = TestPlan.Load(filePath2);
|
Assert.AreEqual(1, testPlan.ChildTestSteps.Count);
|
TestPlanReference tpr = testPlan.ChildTestSteps[0] as TestPlanReference;
|
Assert.IsNotNull(tpr);
|
|
ITypeData ti = TypeData.GetTypeData(tpr);
|
|
// ensure there is a property "External Delay"
|
IMemberData mi = ti.GetMembers().FirstOrDefault(m => m.Attributes.Any(xa => (xa as IDisplayAnnotation)?.Name == externalParameterName));
|
Assert.IsNotNull(mi);
|
Assert.AreEqual(defaultValue, mi.GetValue(tpr));
|
|
// ensure there is no property "External_x0020_Delay"
|
Assert.IsNull(ti.GetMembers().FirstOrDefault(m => m.Attributes.Any(xa => (xa as IDisplayAnnotation)?.Name == externalParamaterNameEncoded)));
|
|
// ensure there is no property "prop0"
|
Assert.IsNull(ti.GetMembers().FirstOrDefault(m => m.Attributes.Any(xa => (xa as IDisplayAnnotation)?.Name == externalParamaterNameLegacy)));
|
}
|
|
// Scope for separating the test Deserialization legacy (Load) from Serialization (Save)
|
{
|
// Replace
|
string content = "";
|
using (var str = File.Open(filePath2, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
|
{
|
using (var read = new StreamReader(str))
|
{
|
content = read.ReadToEnd();
|
}
|
}
|
|
Assert.IsTrue(content.Contains($"<{externalParamaterNameEncoded}>"));
|
Assert.IsTrue(content.Contains($"</{externalParamaterNameEncoded}>"));
|
Assert.IsFalse(content.Contains($"<{externalParameterName}>"));
|
Assert.IsFalse(content.Contains($"</{externalParameterName}>"));
|
Assert.IsFalse(content.Contains($"<{externalParamaterNameLegacy}>"));
|
Assert.IsFalse(content.Contains($"</{externalParamaterNameLegacy}>"));
|
|
content = content.Replace(externalParamaterNameEncoded, externalParamaterNameLegacy);
|
|
Assert.IsFalse(content.Contains($"<{externalParamaterNameEncoded}>"));
|
Assert.IsFalse(content.Contains($"</{externalParamaterNameEncoded}>"));
|
Assert.IsFalse(content.Contains($"<{externalParameterName}>"));
|
Assert.IsFalse(content.Contains($"</{externalParameterName}>"));
|
Assert.IsTrue(content.Contains($"<{externalParamaterNameLegacy}>"));
|
Assert.IsTrue(content.Contains($"</{externalParamaterNameLegacy}>"));
|
|
Assert.IsFalse(File.Exists(filePath3));
|
using (var str = File.Open(filePath3, FileMode.Create, FileAccess.Write, FileShare.ReadWrite))
|
{
|
using (var write = new StreamWriter(str))
|
{
|
write.Write(content);
|
}
|
}
|
Assert.IsTrue(File.Exists(filePath3));
|
|
// Load the test case and its test ref
|
TestPlan testPlan = TestPlan.Load(filePath3);
|
Assert.AreEqual(1, testPlan.ChildTestSteps.Count);
|
TestPlanReference tpr = testPlan.ChildTestSteps[0] as TestPlanReference;
|
Assert.IsNotNull(tpr);
|
|
ITypeData ti = TypeData.GetTypeData(tpr);
|
|
// ensure there is a property "External Delay"
|
IMemberData mi = ti.GetMembers().FirstOrDefault(m => m.Attributes.Any(xa => (xa as IDisplayAnnotation)?.Name == externalParameterName));
|
Assert.IsNotNull(mi);
|
Assert.AreEqual(defaultValue, mi.GetValue(tpr));
|
|
// ensure there is no property "External_x0020_Delay"
|
Assert.IsNull(ti.GetMembers().FirstOrDefault(m => m.Attributes.Any(xa => (xa as IDisplayAnnotation)?.Name == externalParamaterNameEncoded)));
|
|
// ensure there is no property "prop0"
|
Assert.IsNull(ti.GetMembers().FirstOrDefault(m => m.Attributes.Any(xa => (xa as IDisplayAnnotation)?.Name == externalParamaterNameLegacy)));
|
}
|
}
|
finally
|
{
|
if (File.Exists(filePath1))
|
{
|
File.Delete(filePath1);
|
}
|
if (File.Exists(filePath2))
|
{
|
File.Delete(filePath2);
|
}
|
if (File.Exists(filePath3))
|
{
|
File.Delete(filePath3);
|
}
|
}
|
}
|
|
[Test]
|
public void SaveAndLoadExternalScopeParameters()
|
{
|
var plan = new TestPlan();
|
var sequence = new SequenceStep();
|
var delay = new DelayStep();
|
plan.Steps.Add(sequence);
|
sequence.ChildTestSteps.Add(delay);
|
var newmember = TypeData.GetTypeData(delay).GetMember(nameof(DelayStep.DelaySecs))
|
.Parameterize(sequence, delay, nameof(DelayStep.DelaySecs));
|
var fwd = newmember.Parameterize(plan, sequence, nameof(DelayStep.DelaySecs));
|
|
Assert.AreEqual(1, plan.ExternalParameters.Entries.Count);
|
var xml = plan.SerializeToString();
|
var newplan = Utils.DeserializeFromString<TestPlan>(xml);
|
|
Assert.AreEqual(1, newplan.ExternalParameters.Entries.Count);
|
}
|
|
[Test]
|
public void MultiSelectEditParametersDisabled()
|
{
|
var plan = new TestPlan();
|
|
var sequence = new SequenceStep();
|
var delay = new DelayStep();
|
plan.Steps.Add(sequence);
|
sequence.ChildTestSteps.Add(delay);
|
|
var p1 = TypeData.GetTypeData(delay).GetMember(nameof(DelayStep.DelaySecs))
|
.Parameterize(sequence, delay, nameof(DelayStep.DelaySecs));
|
|
var sequence2 = new SequenceStep();
|
var delay2 = new DelayStep();
|
plan.Steps.Add(sequence2);
|
sequence2.ChildTestSteps.Add(delay2);
|
|
var p2 = TypeData.GetTypeData(delay2).GetMember(nameof(DelayStep.DelaySecs))
|
.Parameterize(sequence2, delay2, nameof(DelayStep.DelaySecs));
|
|
|
Assert.NotNull(p1);
|
Assert.NotNull(p2);
|
|
var models = new ITestStepParent[][]
|
{
|
new ITestStepParent[] {sequence, sequence2},
|
new ITestStepParent[] {sequence},
|
new ITestStepParent[] {sequence2}
|
};
|
|
foreach (var stepModel in models)
|
{
|
var stepsModel = AnnotationCollection.Annotate(stepModel);
|
var delayAnnotation = stepsModel.GetMember(nameof(DelayStep.DelaySecs));
|
var menu = delayAnnotation.Get<MenuAnnotation>();
|
var edit = menu.MenuItems.FirstOrDefault(x =>
|
x.Get<IconAnnotationAttribute>()?.IconName == IconNames.EditParameter);
|
|
var access = edit.Get<IAccessAnnotation>();
|
|
Assert.AreEqual(access.IsVisible, stepModel.Length == 1);
|
}
|
}
|
|
[Test]
|
public void ExternalParametersPlusReloadPlugins()
|
{
|
var plan = new TestPlan();
|
var delay = new DelayStep();
|
plan.ChildTestSteps.Add(delay);
|
|
var preMember = TypeData.GetTypeData(delay).GetMember(nameof(DelayStep.DelaySecs))
|
.Parameterize(plan, delay, nameof(DelayStep.DelaySecs));
|
|
var xmlPreSearch = plan.SerializeToString();
|
|
// searching for plugins should not affect serialization.
|
PluginManager.Search();
|
var xmlPostSearch = plan.SerializeToString();
|
|
Assert.AreEqual(xmlPreSearch, xmlPostSearch);
|
}
|
}
|
}
|
