using System;
|
using System.Collections.Generic;
|
using System.IO;
|
using System.Linq;
|
using NUnit.Framework;
|
using OpenTap.EngineUnitTestUtils;
|
using OpenTap.Plugins.BasicSteps;
|
|
namespace OpenTap.UnitTests
|
{
|
[TestFixture]
|
public class ElementFactoryTest
|
{
|
public class ClassWithComplexList
|
{
|
public class ComplexElement
|
{
|
readonly ClassWithComplexList Parent;
|
|
internal ComplexElement(ClassWithComplexList parent)
|
{
|
this.Parent = parent;
|
}
|
}
|
|
public class ComplexList : List<ComplexElement>
|
{
|
readonly ClassWithComplexList parent;
|
public ComplexList(ClassWithComplexList lst)
|
{
|
this.parent = lst;
|
}
|
}
|
|
public class ComplexList2 : List<int>
|
{
|
readonly ClassWithComplexList parent;
|
public ComplexList2(ClassWithComplexList lst)
|
{
|
this.parent = lst;
|
}
|
}
|
[ElementFactory(nameof(NewElement))]
|
public List<ComplexElement> Items { get; set; } = new List<ComplexElement>();
|
|
[ElementFactory(nameof(NewElement))]
|
[Factory(nameof(NewComplexList))]
|
public ComplexList Items2 { get; set; }
|
|
[Factory(nameof(NewComplexList))]
|
public ComplexList Items3 { get; set; }
|
|
|
// Complex list, simple elements
|
[Factory(nameof(NewComplexList2))]
|
public ComplexList2 Items4 { get; set; }
|
|
|
[Factory(nameof(NewComplexList))]
|
[ElementFactory(nameof(NewElement))]
|
public ComplexList Items5 { get; set; }
|
|
internal ComplexElement NewElement()
|
{
|
return new ComplexElement(this);
|
}
|
|
internal ComplexList NewComplexList()
|
{
|
return new ComplexList(this);
|
}
|
|
internal ComplexList2 NewComplexList2()
|
{
|
return new ComplexList2(this);
|
}
|
|
public ClassWithComplexList()
|
{
|
Items2 = new ComplexList(this);
|
Items5 = new ComplexList(this);
|
}
|
|
}
|
|
[Test]
|
public void SerializeWithElementFactory()
|
{
|
|
var test = new ClassWithComplexList();
|
test.Items.Add(test.NewElement());
|
test.Items2.Add(test.NewElement());
|
test.Items5.Add(test.NewElement());
|
test.Items4 = test.NewComplexList2();
|
test.Items4.Add(10);
|
|
var xml = new TapSerializer().SerializeToString(test);
|
|
var test2 =(ClassWithComplexList) new TapSerializer(){IgnoreErrors = false}.DeserializeFromString(xml);
|
Assert.AreEqual(1, test2.Items2.Count);
|
Assert.IsNotNull(test2.Items2[0]);
|
Assert.AreEqual(1, test2.Items.Count);
|
Assert.IsNotNull(test2.Items[0]);
|
Assert.IsNotNull(test2.Items5);
|
Assert.AreEqual(1, test2.Items5.Count);
|
|
Assert.AreEqual(10, test2.Items4[0]);
|
}
|
|
[Test]
|
public void AnnotateWithElementFactory()
|
{
|
var test = new ClassWithComplexList();
|
var a = AnnotationCollection.Annotate(test);
|
var complexItems = a.GetMember(nameof(test.Items2));
|
var collection = complexItems.Get<ICollectionAnnotation>();
|
collection.AnnotatedElements = collection.AnnotatedElements.Append(collection.NewElement());
|
int preCount = test.Items2.Count;
|
a.Write();
|
int postCount = test.Items2.Count;
|
|
Assert.AreEqual(0, preCount);
|
Assert.AreEqual(1, postCount);
|
|
}
|
|
[Test]
|
public void TestDeserializeParameterizedElements([Values(0, 1, 2, 3, 10)] int numRows)
|
{
|
using var s = Session.Create(SessionOptions.OverlayComponentSettings);
|
var trace = new TestTraceListener();
|
Log.AddListener(trace);
|
|
var plan = new TestPlan();
|
var sweep = new SweepParameterStep();
|
var delay = new DelayStep();
|
sweep.ChildTestSteps.Add(delay);
|
plan.ChildTestSteps.Add(sweep);
|
{ /* parameterize DelaySecs */
|
var delaySecs = AnnotationCollection.Annotate(delay).GetMember(nameof(delay.DelaySecs));
|
var mem = delaySecs.Get<IMemberAnnotation>().Member;
|
mem.Parameterize(sweep, delay, $"Parameters \\ {mem.GetDisplayAttribute().Name}");
|
}
|
|
{ /* parameterize sweep values on test plan */
|
var sweepValues = AnnotationCollection.Annotate(sweep).GetMember(nameof(sweep.SweepValues));
|
|
var col = sweepValues.Get<ICollectionAnnotation>();
|
|
void addDelay(double delay)
|
{
|
var elem1 = col.NewElement();
|
var delayMem = elem1.GetMember("Parameters \\ Time Delay");
|
delayMem.Get<IObjectValueAnnotation>().Value = delay;
|
col.AnnotatedElements = col.AnnotatedElements.Append(elem1);
|
}
|
|
for (int i = 1; i <= numRows; i++)
|
{
|
addDelay(i);
|
}
|
|
sweepValues.Write();
|
sweepValues.Read();
|
|
var mem = sweepValues.Get<IMemberAnnotation>().Member;
|
mem.Parameterize(plan, sweep, $"Parameters \\ {mem.GetDisplayAttribute().Name}");
|
}
|
|
TestPlan plan2 = null;
|
{
|
var ser = new TapSerializer() { IgnoreErrors = false };
|
var planXml = ser.SerializeToString(plan);
|
Assert.That(ser.Errors, Is.Empty);
|
plan2 = ser.DeserializeFromString(planXml) as TestPlan;
|
Assert.That(ser.Errors, Is.Empty);
|
}
|
|
void AssertSweepsEqual(SweepRowCollection sweep1, SweepRowCollection sweep2)
|
{
|
Assert.That(sweep1.Count, Is.EqualTo(numRows));
|
Assert.That(sweep2.Count, Is.EqualTo(numRows));
|
|
for (int i = 0; i < sweep1.Count; i++)
|
{
|
var d1 = sweep1[i];
|
var d2 = sweep2[i];
|
foreach (var kvp in d1.Values)
|
{
|
var v1 = kvp.Value;
|
var v2 = d2.Values[kvp.Key];
|
Assert.That(v1, Is.EqualTo(v2));
|
}
|
}
|
}
|
|
{ /* verify parameters were correctly deserialized */
|
var sweep1 = (SweepRowCollection)plan.ExternalParameters.Entries[0].Value;
|
var sweep2 = (SweepRowCollection)plan2.ExternalParameters.Entries[0].Value;
|
AssertSweepsEqual(sweep1, sweep2);
|
}
|
|
{
|
var temp = Path.GetTempFileName();
|
TestPlanReference refStep;
|
try
|
{
|
{ /* test wrapping the test plan in a test plan reference step */
|
plan.Save(temp);
|
var parentPlan = new TestPlan();
|
refStep = new TestPlanReference();
|
parentPlan.ChildTestSteps.Add(refStep);
|
refStep.Filepath = new MacroString() { Text = temp };
|
refStep.LoadTestPlan();
|
|
var (parentPlan2, refStep2) = CloneRef(refStep);
|
refStep2.LoadTestPlan();
|
|
{
|
var sweep1 = GetSweepRow(refStep);
|
var sweep2 = GetSweepRow(refStep2);
|
AssertSweepsEqual(sweep1, sweep2);
|
}
|
refStep2.LoadTestPlan();
|
{
|
var sweep1 = GetSweepRow(refStep);
|
var sweep2 = GetSweepRow(refStep2);
|
AssertSweepsEqual(sweep1, sweep2);
|
}
|
}
|
{ /* try adding new elements to the parameterized sweep and verify they are correctly serialized */
|
var a = AnnotationCollection.Annotate(refStep);
|
var sweepValues = a.GetMember("Sweep Values");
|
var col = sweepValues.Get<ICollectionAnnotation>();
|
var elem1 = col.NewElement();
|
var delayMem = elem1.GetMember("Parameters \\ Time Delay");
|
delayMem.Get<IObjectValueAnnotation>().Value = 123;
|
col.AnnotatedElements = col.AnnotatedElements.Append(elem1);
|
a.Write();
|
|
var (_, refStep2) = CloneRef(refStep);
|
numRows += 1;
|
|
{
|
var sweep1 = GetSweepRow(refStep);
|
var sweep2 = GetSweepRow(refStep2);
|
AssertSweepsEqual(sweep1, sweep2);
|
}
|
/* ensure the sweep changes are not lost after reloading */
|
{
|
refStep2.LoadTestPlan();
|
var sweep1 = GetSweepRow(refStep);
|
var sweep2 = GetSweepRow(refStep2);
|
AssertSweepsEqual(sweep1, sweep2);
|
}
|
}
|
}
|
finally
|
{
|
File.Delete(temp);
|
}
|
|
}
|
{ /* verify that there are no warnings or errors logged */
|
trace.Flush();
|
trace.WarningMessage.RemoveAll(warn =>
|
warn.StartsWith("Duplicate Test packages detected.", StringComparison.OrdinalIgnoreCase));
|
Assert.That(trace.WarningMessage, Is.Empty);
|
Assert.That(trace.ErrorMessage, Is.Empty);
|
}
|
static (TestPlan, TestPlanReference) CloneRef(TestPlanReference refStep)
|
{
|
var parentPlan = new TestPlan();
|
parentPlan.ChildTestSteps.Add(refStep);
|
var ser = new TapSerializer() { IgnoreErrors = false };
|
var xml = ser.SerializeToString(parentPlan);
|
Assert.That(ser.Errors, Is.Empty);
|
var plan2 = ser.DeserializeFromString(xml) as TestPlan;
|
Assert.That(ser.Errors, Is.Empty);
|
return (plan2, plan2.ChildTestSteps[0] as TestPlanReference);
|
}
|
static SweepRowCollection GetSweepRow(ITestStepParent p) => AnnotationCollection.Annotate(p).GetMember("Sweep Values").Get<IObjectValueAnnotation>().Value as SweepRowCollection;
|
}
|
}
|
}
|
