using System.Globalization;
|
using NUnit.Framework;
|
using OpenTap.Plugins.BasicSteps;
|
namespace OpenTap.UnitTests;
|
|
[TestFixture]
|
public class ParameterTests
|
{
|
[Test]
|
public void TestMultiLevelParameters()
|
{
|
// copying multi-level parameters has been a problem because the parameter got removed
|
// the moment it was no longer a part of the test plan, even if the parameter was inside the scopes.
|
|
var seq3 = new SequenceStep();
|
var seq = new SequenceStep();
|
var seq2 = new SequenceStep();
|
var delay = new DelayStep();
|
seq.ChildTestSteps.Add(seq2);
|
seq2.ChildTestSteps.Add(delay);
|
seq3.ChildTestSteps.Add(seq);
|
|
TypeData.GetTypeData(delay).GetMember(nameof(delay.DelaySecs)).Parameterize(seq, delay, "A");
|
Assert.IsTrue(TypeData.GetTypeData(seq).GetMember("A") != null);
|
|
seq3.ChildTestSteps.RemoveItems([seq]);
|
|
Assert.IsTrue(TypeData.GetTypeData(seq).GetMember("A") != null);
|
|
}
|
|
[Test]
|
public void TestMemberDataCacheConsistency()
|
{
|
const string correct = "Correct";
|
const string garbage = "Garbage";
|
var step = new DelayStep
|
{
|
Name = correct
|
};
|
|
|
// This is an extremely unlikely sequence of reads and writes,
|
// but this is esentially what can sometimes happen when writing
|
// different merged parameters which affect different subset of the same set of steps.
|
// See the `TestOverlappingMergedParameterWriting` for a more likely scenario triggering this.
|
|
var a = AnnotationCollection.Annotate(step);
|
var mem = a.GetMember(nameof(step.Name));
|
var ov = mem.Get<IObjectValueAnnotation>();
|
|
// 1. Verify the annotation accurately reflects the current value
|
Assert.That(ov.Value, Is.EqualTo(correct));
|
// 2. Assign a value, but don't write it
|
ov.Value = garbage;
|
|
// 3. Read the annotation back
|
a.Read();
|
// 4. Write the current annotation
|
a.Write();
|
// 5. Verify the garbage value was not written.
|
Assert.That(step.Name, Is.EqualTo(correct));
|
}
|
|
// Exhaustive list of assignment order to assign the parameterized members
|
[TestCase(0, 1, 2)]
|
[TestCase(0, 2, 1)]
|
[TestCase(1, 0, 2)]
|
[TestCase(1, 2, 0)]
|
[TestCase(2, 1, 0)]
|
[TestCase(2, 0, 1)]
|
public void TestOverlappingMergedParameterWriting(int x, int y, int z)
|
{
|
int[] assignmentOrder = [x, y, z];
|
var plan = new TestPlan();
|
var nameParameterName = "shared_name";
|
var delay1ParameterName = "delay_name1";
|
var delay2ParameterName = "delay_name2";
|
plan.ChildTestSteps.AddRange([ new DelayStep(), new DelayStep(), new DelayStep(), new DelayStep(), new DelayStep() ]);
|
|
// Create a merged parameters spanning all 5 steps
|
foreach (var p in plan.ChildTestSteps)
|
{
|
var mem = AnnotationCollection.Annotate(p).GetMember(nameof(p.Name)).Get<IMemberAnnotation>().Member;
|
mem.Parameterize(plan, p, nameParameterName);
|
}
|
|
// Create a merged parameter on the first three steps
|
for (int i = 0; i < 3; i++)
|
{
|
var step = plan.ChildTestSteps[i];
|
var mem = AnnotationCollection.Annotate(step).GetMember(nameof(DelayStep.DelaySecs))
|
.Get<IMemberAnnotation>().Member;
|
mem.Parameterize(plan, step, delay1ParameterName);
|
}
|
|
// Create a merged parameter on the last two steps
|
for (int i = 3; i < 5; i++)
|
{
|
var step = plan.ChildTestSteps[i];
|
var mem = AnnotationCollection.Annotate(step).GetMember(nameof(DelayStep.DelaySecs))
|
.Get<IMemberAnnotation>().Member;
|
mem.Parameterize(plan, step, delay2ParameterName);
|
}
|
|
var a = AnnotationCollection.Annotate(plan);
|
var nameParameter = a.GetMember(nameParameterName);
|
var delayParameter1 = a.GetMember(delay1ParameterName);
|
var delayParameter2 = a.GetMember(delay2ParameterName);
|
|
var name = "Step Name";
|
double delaySecs = 1;
|
double delaySecs2 = 2;
|
|
// parameter assignments. They will be assigned in the order defined by the input parameters, xyz
|
(AnnotationCollection a, string val)[] pairs =
|
[
|
(nameParameter, name),
|
(delayParameter1, delaySecs.ToString(CultureInfo.InvariantCulture)),
|
(delayParameter2, delaySecs2.ToString(CultureInfo.InvariantCulture)),
|
];
|
|
// Ensure the assignment works reliably by looping a few times
|
// During debugging, I saw scenarios where the assignment worked every 2nd time because
|
// a cache was invalidated after a write which was conditional on the cache being invalidated.
|
for (int i = 0; i < 10; i++)
|
{
|
// 1. Assign the parameter values
|
for (int j = 0; j < assignmentOrder.Length; j++)
|
{
|
var pair = pairs[assignmentOrder[j]];
|
pair.a.Read();
|
var sv = pair.a.Get<IStringValueAnnotation>();
|
sv.Value = pair.val;
|
pair.a.Write();
|
}
|
|
// 2. Verify the correct values were propagated to all steps
|
{
|
foreach (var step in plan.ChildTestSteps)
|
{
|
Assert.That(step.Name, Is.EqualTo(name));
|
}
|
|
for (int k = 0; k < 3; k++)
|
{
|
Assert.That((plan.ChildTestSteps[k] as DelayStep).DelaySecs, Is.EqualTo(delaySecs));
|
}
|
|
for (int k = 3; k < 5; k++)
|
{
|
Assert.That((plan.ChildTestSteps[k] as DelayStep).DelaySecs, Is.EqualTo(delaySecs2));
|
}
|
}
|
// reset the parameter values for the next loop iteration
|
{
|
foreach (var step in plan.ChildTestSteps)
|
{
|
step.Name = "doesn't matter";
|
(step as DelayStep).DelaySecs = 123;
|
}
|
}
|
}
|
}
|
|
[Test]
|
public void TestRemoveParameter()
|
{
|
var seq = new SequenceStep();
|
var delay = new DelayStep();
|
seq.ChildTestSteps.Add(delay);
|
var plan = new TestPlan();
|
plan.ChildTestSteps.Add(seq);
|
|
var td = TypeData.GetTypeData(delay);
|
var mem = td.GetMember(nameof(delay.DelaySecs));
|
var aMember = mem.Parameterize(seq, delay, "A 1");
|
|
Assert.IsNotNull(TypeData.GetTypeData(seq).GetMember("A 1"));
|
aMember.Remove();
|
Assert.IsNull(TypeData.GetTypeData(seq).GetMember("A 1"));
|
}
|
|
}
|
