public void MacroExpandTest()
{
EngineSettings.Current.StationName = "__station_name__";
var macro = new MacroString()
{
Text = "test<Date> <Station>"
};
var result = macro.Expand();
Assert.IsTrue(result.EndsWith(EngineSettings.Current.StationName));
macro.Text = macro.Text + "<ThisIsTBD>";
var result2 = macro.Expand(); // Since ThisIsTBD does not exist, we have to run through all possible expansions.
Assert.IsTrue(result2.EndsWith("TBD"));
// Check that when chars that are invalid path characters are used it still works.
var prevStationName = EngineSettings.Current.StationName;
EngineSettings.Current.StationName = "esc!@#%^&*(~)_+{{}\":?>><,m\"\"''";
macro.Text = "<Station>";
var r = macro.Expand();
Assert.AreEqual(EngineSettings.Current.StationName, r);
EngineSettings.Current.StationName = prevStationName;
}
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 MacroFilePathTestStep()
{
PathToThing = new MacroString(this);
ExpandedString = "";
}
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);
}
}
}
