public void TestPlanReferenceAnnotationTest()
{
var planname = Guid.NewGuid().ToString() + ".TestPlan";
{
var innerplan = new TestPlan();
var step = new DelayStep();
innerplan.Steps.Add(step);
innerplan.ExternalParameters.Add(step,
TypeData.GetTypeData(step).GetMember(nameof(DelayStep.DelaySecs)));
innerplan.Save(planname);
}
try
{
var outerplan = new TestPlan();
var tpr = new TestPlanReference();
outerplan.Steps.Add(tpr);
tpr.Filepath.Text = planname;
tpr.LoadTestPlan();
var annotation = AnnotationCollection.Annotate(tpr);
var members = annotation.Get <IMembersAnnotation>().Members;
var delaymem = annotation.GetMember("Time Delay");
Assert.IsNotNull(delaymem);
}
finally
{
File.Delete(planname);
}
}
public void ListOfStringAnnotationTpr()
{
var tp = new TestPlan();
var stepa = new ClassWithListOfString();
var selectedMember = TypeData.GetTypeData(stepa).GetMember(nameof(ClassWithListOfString.Selected));
var stepb = new ClassWithListOfString();
tp.ChildTestSteps.Add(stepa);
tp.ChildTestSteps.Add(stepb);
selectedMember.Parameterize(tp, stepa, selectedMember.Name);
selectedMember.Parameterize(tp, stepb, selectedMember.Name);
var name = Guid.NewGuid().ToString() + ".TapPlan";
tp.Save(name);
var plan2 = new TestPlan();
var tpr = new TestPlanReference();
plan2.ChildTestSteps.Add(tpr);
tpr.Filepath.Text = name;
tpr.LoadTestPlan();
File.Delete(name);
var member = AnnotationCollection.Annotate(tpr).GetMember(selectedMember.Name);
var avail = member.Get <IAvailableValuesAnnotation>();
Assert.AreEqual(2, avail.AvailableValues.Cast <object>().Count());
}
public void SaveLoadPerformance()
{
for (int j = 1; j < 20; j++)
{
int innerSteps = j * 5;
int outerSteps = 10;
var innerPlanName = Path.Combine(Path.GetTempPath(), Guid.NewGuid() + ".TapPlan");
var outerPlanName = Path.Combine(Path.GetTempPath(), Guid.NewGuid() + ".TapPlan");
{
var innerPlan = new TestPlan();
for (int i = 0; i < innerSteps; i++)
{
var step = new DialogStep();
innerPlan.Steps.Add(new DialogStep());
var td = TypeData.GetTypeData(step);
foreach (var mem in td.GetMembers())
{
if (mem.Writable == false)
{
continue;
}
if (mem.IsBrowsable() == false)
{
continue;
}
if (mem.HasAttribute <XmlIgnoreAttribute>())
{
continue;
}
innerPlan.ExternalParameters.Add(step, mem, mem.Name);
}
}
innerPlan.Save(innerPlanName);
}
{
var outerPlan = new TestPlan();
for (int i = 0; i < outerSteps; i++)
{
var tpr = new TestPlanReference();
tpr.Filepath.Text = innerPlanName;
outerPlan.Steps.Add(tpr);
}
outerPlan.Save(outerPlanName);
}
{
var sw = Stopwatch.StartNew();
var loadPlan = TestPlan.Load(outerPlanName);
var loadtime = sw.Elapsed;
sw.Restart();
loadPlan.Save(outerPlanName);
var savetime = sw.Elapsed;
Debug.WriteLine("{2}, {0}, {1}", loadtime.TotalMilliseconds,
savetime.TotalMilliseconds, outerSteps);
}
}
}
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 DisplayAttribute)?.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);
}
}
}
public void TestPlanReferenceNameTest()
{
var step = new DelayStep();
var testPlanReference = new TestPlanReference();
var repeatStep = new RepeatStep();
repeatStep.ChildTestSteps.Add(testPlanReference);
var plan = new TestPlan();
plan.ChildTestSteps.Add(step);
plan.ChildTestSteps.Add(repeatStep);
var mem = AnnotationCollection.Annotate(repeatStep).Get <IMembersAnnotation>().Members
.FirstOrDefault(x => x.Get <IMemberAnnotation>().Member.Name == nameof(RepeatStep.TargetStep));
var avail = mem.Get <IAvailableValuesAnnotationProxy>().AvailableValues;
var availStrings = avail.Select(x => x.Get <IStringReadOnlyValueAnnotation>().Value).ToArray();
Assert.IsTrue(availStrings.Contains(step.GetFormattedName()));
Assert.IsTrue(availStrings.Contains(testPlanReference.GetFormattedName()));
}
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=\"[email protected]\" 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 DisplayAttribute)?.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 DisplayAttribute)?.Name == externalParamaterNameEncoded)));
// ensure there is no property "prop0"
Assert.IsNull(ti.GetMembers().FirstOrDefault(m => m.Attributes.Any(xa => (xa as DisplayAttribute)?.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 DisplayAttribute)?.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 DisplayAttribute)?.Name == externalParamaterNameEncoded)));
// ensure there is no property "prop0"
Assert.IsNull(ti.GetMembers().FirstOrDefault(m => m.Attributes.Any(xa => (xa as DisplayAttribute)?.Name == externalParamaterNameLegacy)));
}
}
finally
{
if (File.Exists(filePath1))
{
File.Delete(filePath1);
}
if (File.Exists(filePath2))
{
File.Delete(filePath2);
}
if (File.Exists(filePath3))
{
File.Delete(filePath3);
}
}
}
