// 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 System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Linq;
|
using NUnit.Framework;
|
|
namespace OpenTap.Engine.UnitTests
|
{
|
[TestFixture]
|
public class ConnectionTest
|
{
|
public class VirtualPortInstrument : Instrument
|
{
|
public class VirtualPort : Port
|
{
|
public VirtualPort(IResource device, int index) : base(device, "P" + index)
|
{
|
Index = index;
|
}
|
public readonly int Index;
|
public override bool Equals(object obj) => obj is VirtualPort vp && vp.Index == Index && vp.Device == Device;
|
public override int GetHashCode() => (Device?.GetHashCode() ?? 0) + 13 * Index;
|
}
|
|
public int NPorts { get; set; } = 1;
|
|
public IEnumerable<Port> Ports
|
{
|
get
|
{
|
for (int i = 0; i < NPorts; i++)
|
yield return new VirtualPort(this, i);
|
}
|
}
|
}
|
|
/// <summary>
|
/// This test show how virtual ports can be used (ports that represents the same without having reference equality).
|
/// </summary>
|
[Test]
|
public void VirtualPortTest()
|
{
|
var instr = new VirtualPortInstrument()
|
{
|
NPorts = 2
|
};
|
|
var c1 = new RfConnection
|
{
|
Port1 = instr.Ports.First(),
|
Port2 = instr.Ports.Last()
|
};
|
|
var p1 = instr.Ports.First();
|
var p2 = instr.Ports.Last();
|
|
Assert.AreNotEqual(p1,p2);
|
Assert.AreEqual(c1.GetOtherPort(p1), p2);
|
Assert.AreEqual(c1.GetOtherPort(p2), p1);
|
}
|
|
[Test]
|
public void EmptyRfConnectionCableLoss()
|
{
|
var loss = new RfConnection().GetInterpolatedCableLoss(0.0);
|
Assert.AreEqual(0.0, loss);
|
}
|
|
[Test]
|
public void CableLossInterpolationTest()
|
{
|
// check linear (first order) interpolation:
|
RfConnection con = new RfConnection();
|
con.CableLoss.Add(new RfConnection.CableLossPoint { Frequency = 100, Loss = 2 });
|
con.CableLoss.Add(new RfConnection.CableLossPoint { Frequency = 200, Loss = 4 });
|
double loss = con.GetInterpolatedCableLoss(150);
|
Assert.AreEqual(3, loss);
|
|
con = new RfConnection();
|
con.CableLoss.Add(new RfConnection.CableLossPoint { Frequency = 100, Loss = 0 });
|
con.CableLoss.Add(new RfConnection.CableLossPoint { Frequency = 200, Loss = 4 });
|
loss = con.GetInterpolatedCableLoss(175);
|
Assert.AreEqual(3, loss);
|
|
// check extrapolation (zero order):
|
con = new RfConnection();
|
con.CableLoss.Add(new RfConnection.CableLossPoint { Frequency = 100, Loss = 2 });
|
con.CableLoss.Add(new RfConnection.CableLossPoint { Frequency = 200, Loss = 4 });
|
loss = con.GetInterpolatedCableLoss(300);
|
Assert.AreEqual(4, loss);
|
loss = con.GetInterpolatedCableLoss(50);
|
Assert.AreEqual(2, loss);
|
|
// check exact match
|
|
con = new RfConnection();
|
con.CableLoss.Add(new RfConnection.CableLossPoint { Frequency = 100, Loss = 2 });
|
con.CableLoss.Add(new RfConnection.CableLossPoint { Frequency = 200, Loss = 4 });
|
con.CableLoss.Add(new RfConnection.CableLossPoint { Frequency = 300, Loss = 5 });
|
loss = con.GetInterpolatedCableLoss(50);
|
Assert.AreEqual(2, loss);
|
loss = con.GetInterpolatedCableLoss(100);
|
Assert.AreEqual(2, loss);
|
loss = con.GetInterpolatedCableLoss(200);
|
Assert.AreEqual(4, loss);
|
loss = con.GetInterpolatedCableLoss(250);
|
Assert.AreEqual(4.5, loss);
|
loss = con.GetInterpolatedCableLoss(275);
|
Assert.AreEqual(4.75, loss);
|
loss = con.GetInterpolatedCableLoss(300);
|
Assert.AreEqual(5, loss);
|
loss = con.GetInterpolatedCableLoss(400);
|
Assert.AreEqual(5, loss);
|
|
// now generate a large set of cable losses
|
var bigCon = new RfConnection();
|
for (double x = 100; x < 500; x += 0.001)
|
{
|
bigCon.CableLoss.Add(new RfConnection.CableLossPoint()
|
{
|
Frequency = x,
|
Loss = con.GetInterpolatedCableLoss(x)
|
});
|
}
|
|
// shuffle to verify that we are robust to unsorted data.
|
bigCon.CableLoss.Shuffle();
|
|
// calculated cable losses should be more or less the same.
|
con = bigCon;
|
loss = con.GetInterpolatedCableLoss(50);
|
Assert.AreEqual(2, loss);
|
loss = con.GetInterpolatedCableLoss(100);
|
Assert.AreEqual(2, loss);
|
loss = con.GetInterpolatedCableLoss(200);
|
Assert.IsTrue(Math.Abs(4 - loss) < 0.0001);
|
loss = con.GetInterpolatedCableLoss(250);
|
Assert.IsTrue(Math.Abs(4.5 - loss) < 0.0001);
|
loss = con.GetInterpolatedCableLoss(275);
|
Assert.IsTrue(Math.Abs(4.75 - loss) < 0.0001);
|
loss = con.GetInterpolatedCableLoss(300);
|
Assert.IsTrue(Math.Abs(5 - loss) < 0.0001);
|
loss = con.GetInterpolatedCableLoss(400);
|
Assert.IsTrue(Math.Abs(5 - loss) < 0.0001);
|
}
|
|
|
public class RevolverSwitchPosition : ViaPoint
|
{
|
public string Alias { get; set; }
|
|
public RevolverSwitchPosition(IInstrument device, string name)
|
{
|
this.Name = name;
|
this.Device = device;
|
}
|
|
}
|
|
public class ViaPointCollection : IReadOnlyList<RevolverSwitchPosition>
|
{
|
readonly RevolverSwitchPosition[] points;
|
public ViaPointCollection(Instrument device, int count)
|
{
|
points = Enumerable.Range(1, count)
|
.Select(x => new RevolverSwitchPosition(device, $"Switch position {x}"))
|
.ToArray();
|
}
|
|
public IEnumerator<RevolverSwitchPosition> GetEnumerator() => points.OfType<RevolverSwitchPosition>().GetEnumerator();
|
|
IEnumerator IEnumerable.GetEnumerator() => points.GetEnumerator();
|
|
public int Count => points.Length;
|
|
public RevolverSwitchPosition this[int index] => points[index];
|
}
|
|
public class TestRevolverSwitchInstrument : Instrument
|
{
|
public IReadOnlyList<RevolverSwitchPosition> SwitchPositions { get; set; }
|
public RevolverSwitchPort A { get; set; }
|
|
public TestRevolverSwitchInstrument()
|
{
|
SwitchPositions = new ViaPointCollection(this, 6);
|
A = new RevolverSwitchPort(this, "A");
|
}
|
}
|
|
public class RevolverSwitchPort : OutputPort
|
{
|
public string Alias { get; set; }
|
public RevolverSwitchPort(IResource device, string name) : base(device, name)
|
{
|
|
}
|
}
|
|
[Test]
|
public void TestRevolverSwitchInstrumentSerialization()
|
{
|
var instrument = new TestRevolverSwitchInstrument();
|
instrument.SwitchPositions[0].Alias = "test";
|
instrument.A.Alias = "test2";
|
var serializer = new TapSerializer();
|
var xml = serializer.SerializeToString(instrument);
|
var instrument2 = (TestRevolverSwitchInstrument) new TapSerializer().DeserializeFromString(xml);
|
Assert.AreEqual(instrument.SwitchPositions[0].Alias, instrument2.SwitchPositions[0].Alias);
|
Assert.AreEqual(instrument.A.Alias, instrument2.A.Alias);
|
}
|
|
public class VirtualViaInstrument : Instrument
|
{
|
public class VirtualVia : ViaPoint
|
{
|
readonly VirtualViaInstrument instrument;
|
public VirtualVia(VirtualViaInstrument instrument, string name)
|
{
|
this.instrument = instrument;
|
this.Device = instrument;
|
this.Name = name;
|
}
|
|
public override bool IsActive
|
{
|
get => instrument.activeVia == Name;
|
set
|
{
|
if(value)
|
instrument.activeVia = Name;
|
else
|
if(IsActive)
|
instrument.activeVia = null;
|
}
|
}
|
|
public void Activate()
|
{
|
|
}
|
}
|
public VirtualVia via1 { get; }
|
public VirtualVia via2 { get; }
|
string activeVia;
|
public VirtualViaInstrument()
|
{
|
via1 = new VirtualVia(this, "A");
|
via2 = new VirtualVia(this, "B");
|
}
|
}
|
|
[Test]
|
public void TestVirtualVias()
|
{
|
using var _ = Session.Create();
|
var instr = new VirtualViaInstrument();
|
instr.via1.IsActive = true;
|
|
var instr2 = new VirtualPortInstrument{NPorts = 2};
|
InstrumentSettings.Current.AddRange([instr, instr2]);
|
|
var con1 = new RfConnection
|
{
|
Port1 = instr2.Ports.First(),
|
Port2 = instr2.Ports.Last(),
|
Via = new List<ViaPoint>(){instr.via1}
|
};
|
|
var con2 = new RfConnection
|
{
|
Port1 = instr2.Ports.First(),
|
Port2 = instr2.Ports.Last(),
|
Via = new List<ViaPoint>(){instr.via2}
|
};
|
|
ConnectionSettings.Current.Add(con1);
|
ConnectionSettings.Current.Add(con2);
|
|
Assert.IsFalse(con2.IsActive);
|
Assert.IsTrue(con1.IsActive);
|
|
instr.via2.IsActive = true;
|
|
Assert.IsFalse(con1.IsActive);
|
Assert.IsTrue(con2.IsActive);
|
|
instr.via2.IsActive = false;
|
|
Assert.IsFalse(con1.IsActive);
|
Assert.IsFalse(con2.IsActive);
|
}
|
}
|
}
|
