internal TestEventsSender(TestEventsCollector collector, UnitTestLaunch unitTestLaunch)
{
myUnitTestLaunch = unitTestLaunch;
ProcessQueue(collector);
collector.Clear();
collector.ClearEvent();
collector.AddEvent += (col, _) =>
{
ProcessQueue((TestEventsCollector)col);
};
}
private static void SubscribeToChanged(Type data, UnitTestLaunch unitTestLaunch)
{
var eventInfo = data.GetEvent("Changed");
if (eventInfo != null)
{
var handler = new EventHandler((sender, e) => { ProcessQueue(data, unitTestLaunch); });
eventInfo.AddEventHandler(handler.Target, handler);
AppDomain.CurrentDomain.DomainUnload += (EventHandler)((_, __) =>
{
eventInfo.RemoveEventHandler(handler.Target, handler);
});
}
else
{
ourLogger.Error("Changed event subscription failed.");
}
}
internal TestEventsSender(UnitTestLaunch unitTestLaunch)
{
var assembly = RiderPackageInterop.GetAssembly();
if (assembly == null)
{
ourLogger.Error("EditorPlugin assembly is null.");
return;
}
var data = assembly.GetType("Packages.Rider.Editor.UnitTesting.CallbackData");
if (data == null)
{
return;
}
ProcessQueue(data, unitTestLaunch);
SubscribeToChanged(data, unitTestLaunch);
}
private static void ProcessQueue(Type data, UnitTestLaunch unitTestLaunch)
{
if (!unitTestLaunch.IsBound)
{
return;
}
var baseType = data.BaseType;
if (baseType == null)
{
return;
}
var instance = baseType.GetProperty("instance");
if (instance == null)
{
return;
}
var instanceVal = instance.GetValue(null, new object[] {});
var listField = data.GetField("events");
if (listField == null)
{
return;
}
var list = listField.GetValue(instanceVal);
var events = (IEnumerable)list;
foreach (var ev in events)
{
var type = (int)ev.GetType().GetField("type").GetValue(ev);
var id = (string)ev.GetType().GetField("id").GetValue(ev);
var assemblyName = (string)ev.GetType().GetField("assemblyName").GetValue(ev);
var output = (string)ev.GetType().GetField("output").GetValue(ev);
var resultState = (int)ev.GetType().GetField("testStatus").GetValue(ev);
var duration = (double)ev.GetType().GetField("duration").GetValue(ev);
var parentId = (string)ev.GetType().GetField("parentId").GetValue(ev);
switch (type)
{
case 0: // TestStarted
{
var tResult = new TestResult(id, assemblyName, string.Empty, 0, Status.Running, parentId);
TestStarted(unitTestLaunch, tResult);
break;
}
case 1: // TestFinished
{
var status = GetStatus(new ResultState((TestStatus)resultState));
var testResult = new TestResult(id, assemblyName, output, (int)duration,
status, parentId);
TestFinished(unitTestLaunch, testResult);
break;
}
case 2: // RunFinished
{
var runResult = new RunResult((TestStatus)resultState == TestStatus.Passed);
RunFinished(unitTestLaunch, runResult);
break;
}
case 3: // RunStarted
{
unitTestLaunch.RunStarted.Value = true;
break;
}
default:
{
ourLogger.Error("Unexpected TestEvent type.");
break;
}
}
}
var clearMethod = data.GetMethod("Clear");
clearMethod?.Invoke(instanceVal, new object[] {});
}
public static void TestFinished(UnitTestLaunch launch, TestResult testResult)
{
launch.TestResult(testResult);
}
public static void TestStarted(UnitTestLaunch launch, TestResult testResult)
{
launch.TestResult(testResult);
}
public static void RunFinished(UnitTestLaunch launch, RunResult result)
{
launch.RunResult(result);
}
public static void RunFinished(UnitTestLaunch launch)
{
launch.RunResult.Fire(new RunResult(true));
}
public UnityEditorTestLauncher(UnitTestLaunch launch, Lifetime connectionLifetime)
{
myLaunch = launch;
myConnectionLifetime = connectionLifetime;
}
internal static void SupportAbortNew(UnitTestLaunch launch)
{
try
{
const string assemblyName = "UnityEditor.TestRunner";
const string typeName = "UnityEditor.TestTools.TestRunner.Api.TestRunnerApi";
const string methodName = "CancelAllTestRuns";
MethodInfo stopRunMethod = null;
var assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(a => a.GetName().Name.Equals(assemblyName));
if (assembly == null)
{
ourLogger.Verbose($"Could not find {assemblyName} in the AppDomain.");
}
else
{
var apiType = assembly.GetType(typeName);
if (apiType == null)
{
ourLogger.Verbose($"Could not find {typeName} in the {assemblyName}.");
}
else
{
stopRunMethod = apiType.GetMethod(methodName);
if (stopRunMethod == null)
{
ourLogger.Verbose($"Could not find {methodName} in the {typeName}.");
}
}
}
launch.Abort.Set((lifetime, _) =>
{
var task = new RdTask <bool>();
if (stopRunMethod != null)
{
ourLogger.Verbose($"Call {methodName} method via reflection.");
try
{
stopRunMethod.Invoke(null, null);
task.Set(true);
if (!launch.RunStarted.HasTrueValue()) // if RunStarted never happened
{
launch.RunResult(new RunResult(false));
}
}
catch (Exception)
{
ourLogger.Verbose($"Call {methodName} method failed.");
task.Set(false);
}
}
else
{
task.Set(false);
}
return(task);
});
}
catch (Exception e)
{
ourLogger.Error(e, "Unexpected exception in SupportAbortNew");
}
}
public UnityEditorTestLauncher(UnitTestLaunch launch)
{
myLaunch = launch;
}
