// 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 NUnit.Framework;
|
using System;
|
using System.Threading;
|
using System.Linq;
|
using System.Collections.Generic;
|
using System.Diagnostics;
|
using System.IO;
|
using System.Xml.Serialization;
|
using Microsoft.CSharp;
|
using System.CodeDom.Compiler;
|
using System.Reflection;
|
using OpenTap.EngineUnitTestUtils;
|
using System.Threading.Tasks;
|
using OpenTap;
|
|
namespace OpenTap.Engine.UnitTests
|
{
|
|
|
/// <summary>
|
///This is a test class for PluginManagerTest and is intended
|
///to contain all PluginManagerTest Unit Tests
|
///</summary>
|
[TestFixture]
|
public class PluginManagerTest
|
{
|
/// <summary>
|
///A test for SearchAsync
|
///</summary>
|
[Test]
|
public void SearchAsyncTest()
|
{
|
PluginManager.SearchAsync().Wait();
|
Assert.IsTrue(PluginManager.GetPlugins(typeof(IResultListener)).Any(), "Search did not find database interface.");
|
Assert.IsTrue(PluginManager.GetPlugins(typeof(ITestStep)).Any(), "Search did not find any teststeps.");
|
}
|
|
private static void DeleteFile(string assemblyFileName)
|
{
|
int retries = 0;
|
while (File.Exists(assemblyFileName))
|
{
|
try
|
{
|
File.Delete(assemblyFileName);
|
}
|
catch
|
{
|
Thread.Sleep(50);
|
if (retries++ > 20)
|
break;
|
}
|
}
|
}
|
private static void GeneratePluginAssembly(string assemblyFileName, string testStepName, string guid = "634896ca-7e6a-c66d-5ef7-2c2d2a5c3f30", string customcode = "")
|
{
|
string cs = "";
|
cs += "using System.Reflection;";
|
cs += "using System.Runtime.InteropServices;";
|
cs += "using OpenTap;";
|
cs += "[assembly: Guid(\"" + guid + "\")]";
|
cs += customcode;
|
cs += "public class " + testStepName + " : TestStep { public override void Run(){} }";
|
|
CSharpCodeProvider provider = new CSharpCodeProvider();
|
CompilerParameters parameters = new CompilerParameters();
|
parameters.ReferencedAssemblies.Add("System.dll");
|
parameters.ReferencedAssemblies.Add("OpenTap.dll");
|
parameters.GenerateInMemory = false;
|
parameters.GenerateExecutable = false;
|
parameters.OutputAssembly = Path.Combine(Path.GetTempPath(), Path.GetFileName(assemblyFileName));
|
CompilerResults results = provider.CompileAssemblyFromSource(parameters, cs);
|
if (results.Errors.HasErrors)
|
{
|
var errors = results.Errors.Cast<CompilerError>().Select(err => err.ToString());
|
Assert.Inconclusive(String.Join("\r\n", errors));
|
}
|
|
DeleteFile(assemblyFileName);
|
File.Move(results.PathToAssembly, assemblyFileName);
|
DeleteFile(results.PathToAssembly);
|
}
|
|
//[Test, Ignore("We dont know what this actually does")]
|
//public void DirectoriesToSearchTest()
|
//{
|
// //This Test requires OpenTAP to be installed
|
|
// // Make sure we have the stuff we need in a temp dir:
|
// string baseDir = Path.Combine(Path.GetTempPath(), "DirectoriesToSearchTest");
|
// Directory.CreateDirectory(baseDir);
|
// File.Copy(Assembly.GetExecutingAssembly().Location, Path.Combine(baseDir, Path.GetFileName(Assembly.GetExecutingAssembly().Location)), true);
|
// File.Copy("OpenTap.dll", Path.Combine(baseDir, "OpenTap.dll"), true);
|
// File.Copy("Keysight.Ccl.Licensing.Api.dll", Path.Combine(baseDir, "Keysight.Ccl.Licensing.Api.dll"), true);
|
// File.Copy("System.Reflection.Metadata.dll", Path.Combine(baseDir, "System.Reflection.Metadata.dll"), true);
|
// File.Copy("System.Collections.Immutable.dll", Path.Combine(baseDir, "System.Collections.Immutable.dll"), true);
|
|
// // Run PluginManager.Search from the temp dir while specifying TAP_PATH as an additional directory to search:
|
// AppDomainSetup setup = new AppDomainSetup { ApplicationBase = baseDir };
|
// AppDomain domain = AppDomain.CreateDomain("TestSearchDomain", null, setup);
|
// List<string> asms = new List<string>();
|
// domain.DoCallBack(() =>
|
// {
|
// TestTraceListener log = new TestTraceListener();
|
// Log.AddListener(logOpenTAP
|
// // Ask to look for plugins in TAP installation dir as well as current dir
|
// // (current dir should be different from OpenTAP installation dir for the bug to show)
|
// PluginManager.DirectoriesToSearch.Add(Environment.GetEnvironmentVariable("TAP_PATH"));
|
// var d = AppDomain.CurrentDomain;
|
// var l = log.GetLog();
|
// d.SetData("log", l);
|
// });
|
// string logText = (string)domain.GetData("log");
|
// AppDomain.Unload(domain);
|
|
// // This can fail if a plugin in the other Dir to search (in this test TAP_PATH)
|
// // cannot be loaded because a dependency cannot be found.
|
// Assert.IsFalse(System.Text.RegularExpressions.Regex.IsMatch(logText, "Missing required assembly"));
|
//}
|
|
[Test]
|
public void ExtensionTest()
|
{
|
int Min = -10;
|
int Max = 20;
|
IEnumerable<int> ints = Enumerable.Range(Min, Max - Min + 1).ToList();
|
int min = ints.FindMin(i => i);
|
int max = ints.FindMax(i => i);
|
Debug.Assert(min == Min);
|
Debug.Assert(max == Max);
|
Debug.Assert(max == ints.FindMin(i => -i));
|
}
|
|
/// <summary>
|
/// Same assembly two different locations.
|
/// </summary>
|
[Test, Ignore("?")]
|
public void SameAssemblyTwiceLoaded()
|
{
|
OpenTap.SessionLogs.Initialize("StartupLog.txt");
|
var trace = new TestTraceListener();
|
OpenTap.Log.AddListener(trace);
|
Directory.CreateDirectory("PluginManager.Test");
|
string path1 = "twice.dll";
|
GeneratePluginAssembly(path1, "Test1");
|
string path2 = "PluginManager.Test\\twice.dll";
|
GeneratePluginAssembly(path2, "Test1");
|
try
|
{
|
var d = AppDomain.CurrentDomain;
|
var assemblies = d.GetAssemblies().Where(asm => !asm.IsDynamic).Select(asm => Path.GetFileName(asm.Location)).ToList();
|
Assert.IsTrue(assemblies.Contains("twice.dll"));
|
Log.Flush();
|
var all = trace.allLog.ToString();
|
int times = 0;
|
foreach (var line in all.Split('\n'))
|
if (line.Contains("Warning") && line.Contains("Not loading") && line.Contains("twice.dll"))
|
times++;
|
|
Assert.AreEqual(times, 1);
|
}
|
finally
|
{
|
DeleteFile(path1); //loaded dlls cannot be deleted...
|
DeleteFile(path2);
|
}
|
}
|
|
static void GenerateAssemblyWithVersion(string assemblyFileName, string testStepName, string version, string strongNameKeyFile = null)
|
{
|
string cs = "";
|
cs += "using System.Reflection;\n";
|
cs += "using System.Runtime.InteropServices;\n";
|
cs += "[assembly: Guid(\"634896ca-7e6a-c66d-5ef7-2c2d2a5c3f31\")]\n";
|
cs += "[assembly: AssemblyVersion(\"" + version + "\")]\n";
|
cs += "public class " + testStepName + " { public void Run(){} }";
|
var asmname = Path.GetFileNameWithoutExtension(assemblyFileName);
|
var buildResult = CodeGen.BuildCode(cs, asmname, strongNameKeyFile);
|
Assert.IsTrue(buildResult.Success,buildResult.Log);
|
DeleteFile(assemblyFileName);
|
File.WriteAllBytes(assemblyFileName, buildResult.Bytes);
|
}
|
|
[Test]
|
public void SameAssemblyDifferentVersions()
|
{
|
Directory.CreateDirectory("Test1");
|
Directory.CreateDirectory("Test2");
|
Directory.CreateDirectory("Test3");
|
GenerateAssemblyWithVersion("Test1/Dual1.dll", "MyStep1", version: "1.0.0");
|
GenerateAssemblyWithVersion("Test2/Dual1.dll", "MyStep1", version: "1.2.0");
|
GenerateAssemblyWithVersion("Test3/Dual1.dll", "MyStep1", version: "1.1.0");
|
PluginManager.SearchAsync().Wait();
|
Assert.AreEqual(3,PluginManager.GetSearcher().Assemblies.Count(asm => asm.Name == "Dual1"));
|
var asm1 = Assembly.Load("Dual1");
|
Assert.IsTrue(asm1.GetName().Version.Minor == 2);
|
}
|
|
[Test]
|
public void SameAssemblyDifferentVersions3()
|
{
|
Directory.CreateDirectory("Test1");
|
Directory.CreateDirectory("Test2");
|
Directory.CreateDirectory("Test3");
|
GenerateAssemblyWithVersion("Test1/SameAssemblyDifferentVersions3.dll", "MyStep1", version: "1.0.0");
|
GenerateAssemblyWithVersion("Test2/SameAssemblyDifferentVersions3.dll", "MyStep1", version: "1.2.0");
|
GenerateAssemblyWithVersion("Test3/SameAssemblyDifferentVersions3.dll", "MyStep1", version: "1.1.0");
|
PluginManager.SearchAsync().Wait();
|
var asm1 = Assembly.Load("SameAssemblyDifferentVersions3, Version=1.1.0.0");
|
Assert.AreEqual(1, asm1.GetName().Version.Minor);
|
var asm2 = Assembly.Load("SameAssemblyDifferentVersions3, Version=1.0.0.0"); // here we get still get 1.1 even though we asked for 1.0, because it was already loaded.
|
Assert.AreEqual(1, asm2.GetName().Version.Minor);
|
}
|
|
interface FancyInterface<T>
|
{
|
T X { get; set; }
|
}
|
class FancyType<T> : FancyInterface<int>
|
{
|
public int X { get; set; }
|
}
|
|
[Test]
|
public void ReflectionTest()
|
{
|
Assert.IsTrue(typeof(ITestStep).DescendsTo(typeof(object)));
|
Assert.IsTrue(typeof(ITestStep).DescendsTo(typeof(IValidatingObject)));
|
Assert.IsTrue(typeof(ITestStep).DescendsTo(typeof(System.ComponentModel.INotifyPropertyChanged)));
|
Assert.IsFalse(typeof(ITestStep).DescendsTo(typeof(IInstrument)));
|
Assert.IsTrue(typeof(Instrument).DescendsTo(typeof(IResource)));
|
Assert.IsTrue(typeof(FancyType<int>).DescendsTo(typeof(FancyType<>)));
|
Assert.IsTrue(typeof(FancyType<int>).DescendsTo(typeof(FancyInterface<>)));
|
Assert.IsTrue(typeof(FancyType<int>).DescendsTo(typeof(FancyInterface<int>)));
|
Assert.IsFalse(typeof(FancyType<int>).DescendsTo(typeof(FancyInterface<bool>)));
|
}
|
|
/// <summary>
|
/// Loading of dlls at runtime.
|
/// </summary>
|
[Test]
|
public void DynamicLoading()
|
{
|
// test loading dlls at runtime, by the following procedure:
|
// 1. call search() and get number of TestSteps
|
// 2. Create a new dll with a TestStep in it. (by calling the compiler)
|
// 3. call search() and get number of TestSteps.
|
// 4. The number of steps should have increased by the number of steps in the new assembly.
|
// some of this is done in an AppDomain to be able to unload and delete the DLL
|
// guids are used to generate unique names.
|
|
// the new assembly must have a GUID.
|
var classname = "cls" + Guid.NewGuid().ToString().Replace("-", "");
|
var code =
|
"using OpenTap;\nusing System.Runtime.InteropServices;\nusing System.Reflection;\n"
|
+ "using System.Runtime.CompilerServices;\n[assembly: Guid(\"__GUID__\")]\n"
|
+ "namespace test{public class __NAME__ : TestStep\n{\npublic override void Run(){}\n}}\n";
|
code = code.Replace("__NAME__", classname).Replace("__GUID__", Guid.NewGuid().ToString());
|
|
|
var dll = string.Format("Keysight.Tap.Engine.TestModule_{0}.dll", Guid.NewGuid());
|
int prevcnt = PluginManager.GetAllPlugins().Count();
|
var results = CodeGen.BuildCode(code, Path.GetFileNameWithoutExtension(dll));
|
|
Assert.IsTrue(results.Success);
|
try
|
{
|
File.WriteAllBytes(dll, results.Bytes);
|
PluginManager.SearchAsync(); // starta new search to find the new assembly
|
int postcnt = PluginManager.GetAllPlugins().Count();
|
Assert.IsTrue(prevcnt == postcnt - 1);
|
}
|
finally
|
{
|
File.Delete(dll);
|
}
|
}
|
|
[Test]
|
public void MemorizerThreadTest()
|
{
|
List<Task> tasks = new List<Task>();
|
|
// Testing a very short operation in the memorizer
|
// With a relatively short running tasks to test if we can break the internals of the memorizer.
|
|
var numberThingTest = new Memorizer<int, int>(thing => thing % 25)
|
{ MaxNumberOfElements = 25, SoftSizeDecayTime = TimeSpan.MaxValue };
|
var numberRevertThingTest = new Memorizer<int, int>(thing => -thing)
|
{ MaxNumberOfElements = 25, SoftSizeDecayTime = TimeSpan.MaxValue };
|
for (int i = 0; i < 10; i++)
|
{
|
int _i = i;
|
tasks.Add(Task.Factory.StartNew(() =>
|
{
|
for (int j = 0; j < 1000; j++)
|
{
|
var value1 = numberThingTest.Invoke((_i + j) % 71); // ensure collision of keys.
|
var value2 = numberRevertThingTest.Invoke(value1);
|
Assert.IsTrue(value2 == -(((_i + j) % 71) % 25)); // check calculation.
|
}
|
}));
|
}
|
|
Task.WhenAll(tasks).Wait();
|
Task.WaitAll(tasks.ToArray());
|
|
}
|
|
double modf(double val, double mod)
|
{
|
return Math.Floor((val - Math.Floor(val / mod) * mod) * 1000.0) / 1000.0;
|
}
|
|
|
[Test]
|
public void MemorizerTest()
|
{
|
var times = Enumerable.Range(1, 4).Select(i =>
|
{
|
Memorizer<double, double, double> mem = new Memorizer<double, double, double>(d => modf(d, Math.PI), Math.Sin);
|
var timer = Stopwatch.StartNew();
|
var output = Enumerable.Range(0, (int)Math.Pow(3, i))
|
.Select(i2 => i2 / 20.0)
|
.Select(mem.Invoke).ToList();
|
return timer.Elapsed;
|
}).ToList();
|
|
|
var times2 = Enumerable.Range(1, 4).Select(i =>
|
{
|
//Memorizer<double, double, double> mem = new Memorizer<double, double, double>(d => modf(d, Math.PI), Math.Sin);
|
var timer = Stopwatch.StartNew();
|
var output = Enumerable.Range(0, (int)Math.Pow(3, i))
|
.Select(i2 => i2 / 20.0)
|
.Select(Math.Sin).ToList();
|
return timer.Elapsed;
|
}).ToList();
|
Debug.WriteLine(times);
|
Debug.WriteLine(times2);
|
}
|
|
public class Algorithm
|
{
|
|
public string Name { get; set; }
|
public Algorithm()
|
{
|
Name = "";
|
}
|
}
|
public class Sequence
|
{
|
[XmlAttribute("Name")]
|
public string Name { get; set; }
|
|
[XmlArray]
|
public List<Algorithm> Items { get; set; }
|
public Sequence()
|
{
|
Name = "test2";
|
Items = new List<Algorithm> { new Algorithm { Name = "Test Algorithm" } };
|
}
|
}
|
[Test]
|
public void TestLoadSequence()
|
{
|
XmlSerializer serializer = new XmlSerializer(typeof(Sequence));
|
string testData = "<Sequence><Algorithm Name=\"test\"/></Sequence>";
|
MemoryStream memStream = new MemoryStream(System.Text.Encoding.ASCII.GetBytes(testData));
|
//var output = serializer.Deserialize(memStream);
|
memStream = new MemoryStream(10000);
|
serializer.Serialize(memStream, new Sequence() { Items = new List<Algorithm> { new Algorithm { Name = "test" } } });
|
//Console.WriteLine(output);
|
System.Text.Encoding.ASCII.GetString(memStream.GetBuffer());
|
}
|
|
[Test]
|
public void TestTapPluginTypeAttribute()
|
{
|
var pluginCategory = typeof(ScpiInstrument).GetPluginType();
|
Assert.IsTrue(typeof(IInstrument) == pluginCategory[0]);
|
}
|
|
public class TestStep
|
{
|
// This is not a test step!
|
}
|
|
[Test]
|
public void SameNamedTypes()
|
{
|
Assert.AreEqual(typeof(OpenTap.TestStep), PluginManager.LocateType("OpenTap.TestStep"));
|
Assert.AreEqual(typeof(TestStep), PluginManager.LocateType(typeof(TestStep).FullName));
|
}
|
|
[Test]
|
public void RfConnectionDisplayAttributeTest()
|
{
|
// The following works because the ScpiInstrument gets discovered by PluginManager
|
// and gets its Display attribute from it.
|
var instr = TypeData.GetDerivedTypes<Instrument>().FirstOrDefault(x => x.Name.Contains("ScpiInstrument"));
|
Assert.IsTrue(instr.GetDisplayAttribute().Name == "Generic SCPI Instrument");
|
|
// The following did not work because RfConnection connection was not an ITapPlugin type.
|
var rf = TypeData.GetDerivedTypes<Connection>().FirstOrDefault(x => x.Name == "OpenTap.RfConnection");
|
Assert.IsTrue(rf.GetDisplayAttribute().Name == "RF Connection");
|
}
|
|
[Test]
|
public void ResolveAssemblyVersions()
|
{
|
|
string asm1name = "../ResolveAssemblyVersions/ResolveAssemblyVersions.dll";
|
string asm2name = "../ResolveAssemblyVersions/ResolveAssemblyVersions.2.dll";
|
if(Directory.Exists("../ResolveAssemblyVersions/"))
|
Directory.Delete("../ResolveAssemblyVersions/", true);
|
|
Directory.CreateDirectory("../ResolveAssemblyVersions/");
|
GenerateAssemblyWithVersion(asm1name, "test", "2.2.0.0");
|
GenerateAssemblyWithVersion(asm2name, "test", "2.3.0.0");
|
var asm = Assembly.LoadFrom(asm1name);
|
var asm2 = Assembly.Load("ResolveAssemblyVersions, Version=2.1.0.0, Culture=neutral, PublicKeyToken=null");
|
|
// this should give a warning
|
var asm3 = Assembly.Load("ResolveAssemblyVersions, Version=2.3.0.0, Culture=neutral, PublicKeyToken=null");
|
|
bool noexec = false;
|
if (!noexec)
|
{
|
// This does not work. Once the assembly has failed to load once
|
// we wont try again, even if DirectoriesToSearch has been changed.
|
try
|
{
|
Assembly.Load("ResolveAssemblyVersions.2, Version=2.3.0.0, Culture=neutral, PublicKeyToken=null");
|
Assert.Fail("Load ResolveAssemblyVersions.2 should throw an exception");
|
}
|
catch
|
{
|
|
}
|
}
|
|
PluginManager.DirectoriesToSearch.Add(Path.GetFullPath(@"../ResolveAssemblyVersions/"));
|
var asm4 = Assembly.Load("ResolveAssemblyVersions.2, Version=2.3.0.0, Culture=neutral, PublicKeyToken=null");
|
var asm5 = Assembly.Load("ResolveAssemblyVersions.2, Version=2.1.0.0, Culture=neutral, PublicKeyToken=null");
|
|
Assert.IsTrue(asm == asm2);
|
Assert.IsTrue(asm3 == asm2);
|
|
Assert.IsTrue(asm4 != asm2);
|
Assert.IsTrue(asm4 == asm5);
|
|
}
|
|
[Test]
|
public void PluginInitializerTest()
|
{
|
|
var code =
|
"using OpenTap;"
|
+ "[assembly: PluginAssemblyAttribute (false, \"PluginAssemblyTest.StaticClassTest.Invoke\")]\n"
|
+ "namespace PluginAssemblyTest {public static class StaticClassTest{ public static bool Initialized; public static void Invoke(){Initialized = true;}}" +
|
" public class StaticClassTestTestStep : TestStep {public override void Run(){}}" +
|
"}\n";
|
var dirname = Guid.NewGuid().ToString();
|
var asmName = "PluginAssemblyTest";
|
var tempDir = Path.Combine(Path.GetTempPath(), asmName + dirname);
|
var fileName = Path.Combine(tempDir, asmName + ".dll");
|
if (File.Exists(fileName)) File.Delete(fileName);
|
Directory.CreateDirectory(tempDir);
|
PluginManager.DirectoriesToSearch.Add(tempDir);
|
|
var results = CodeGen.BuildCode(code, asmName);
|
File.WriteAllBytes(fileName, results.Bytes);
|
PluginManager.Search();
|
var td = TypeData.GetTypeData("PluginAssemblyTest.StaticClassTestTestStep");
|
Assert.IsNotNull(td);
|
var td2 = TypeData.GetTypeData("PluginAssemblyTest.StaticClassTest");
|
Assert.IsNotNull(td);
|
var initialized = (bool)td2.As<TypeData>().Type.GetField("Initialized").GetValue(null);
|
Assert.IsTrue(initialized);
|
PluginManager.DirectoriesToSearch.Remove(tempDir);
|
|
}
|
}
|
public class SimpleListTest : TestStep
|
{
|
public List<double> Doubles { get; set; }
|
public List<float> Floats { get; set; }
|
public List<decimal> Decimals { get; set; }
|
public List<byte> Bytes { get; set; }
|
public List<bool> Bools { get; set; }
|
public double ADouble { get; set; }
|
public int AInt { get; set; }
|
|
public override void Run()
|
{
|
throw new NotImplementedException();
|
}
|
}
|
}
|
