1124 строки
38 KiB
C#
1124 строки
38 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Concurrent;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using System.Text;
|
|
|
|
namespace xharness
|
|
{
|
|
public class Jenkins
|
|
{
|
|
public Harness Harness;
|
|
public bool IncludeClassic;
|
|
public bool IncludeBcl;
|
|
|
|
public LogFiles Logs = new LogFiles ();
|
|
LogFile SimulatorLoadLog;
|
|
|
|
public string LogDirectory {
|
|
get {
|
|
return Path.Combine (Harness.JENKINS_RESULTS_DIRECTORY, "tests");
|
|
}
|
|
}
|
|
public Simulators Simulators = new Simulators ();
|
|
|
|
List<TestTask> Tasks = new List<TestTask> ();
|
|
|
|
internal static Resource DesktopResource = new Resource ("Desktop", Environment.ProcessorCount);
|
|
|
|
async Task<IEnumerable<RunSimulatorTask>> CreateRunSimulatorTaskAsync (XBuildTask buildTask)
|
|
{
|
|
var runtasks = new List<RunSimulatorTask> ();
|
|
|
|
Simulators.Harness = Harness;
|
|
if (SimulatorLoadLog == null)
|
|
SimulatorLoadLog = Logs.Create (LogDirectory, "simulator-list.log", "Simulator Listing");
|
|
try {
|
|
await Simulators.LoadAsync (SimulatorLoadLog);
|
|
} catch (Exception e) {
|
|
SimulatorLoadLog.WriteLine ("Failed to load simulators:");
|
|
SimulatorLoadLog.WriteLine (e.ToString ());
|
|
return runtasks;
|
|
}
|
|
|
|
var fn = Path.GetFileNameWithoutExtension (buildTask.ProjectFile);
|
|
if (fn.EndsWith ("-tvos", StringComparison.Ordinal)) {
|
|
var latesttvOSRuntime =
|
|
Simulators.SupportedRuntimes.
|
|
Where ((SimRuntime v) => v.Identifier.StartsWith ("com.apple.CoreSimulator.SimRuntime.tvOS-", StringComparison.Ordinal)).
|
|
OrderBy ((SimRuntime v) => v.Version).
|
|
Last ();
|
|
var tvOSDeviceType =
|
|
Simulators.SupportedDeviceTypes.
|
|
Where ((SimDeviceType v) => v.ProductFamilyId == "TV").
|
|
First ();
|
|
var device =
|
|
Simulators.AvailableDevices.
|
|
Where ((SimDevice v) => v.SimRuntime == latesttvOSRuntime.Identifier && v.SimDeviceType == tvOSDeviceType.Identifier).
|
|
First ();
|
|
runtasks.Add (new RunSimulatorTask (buildTask, device) { Platform = TestPlatform.tvOS });
|
|
} else if (fn.EndsWith ("-watchos", StringComparison.Ordinal)) {
|
|
var latestwatchOSRuntime =
|
|
Simulators.SupportedRuntimes.
|
|
Where ((SimRuntime v) => v.Identifier.StartsWith ("com.apple.CoreSimulator.SimRuntime.watchOS-", StringComparison.Ordinal)).
|
|
OrderBy ((SimRuntime v) => v.Version).
|
|
Last ();
|
|
var watchOSDeviceType =
|
|
Simulators.SupportedDeviceTypes.
|
|
Where ((SimDeviceType v) => v.ProductFamilyId == "Watch").
|
|
First ();
|
|
var device =
|
|
Simulators.AvailableDevices.
|
|
Where ((SimDevice v) => v.SimRuntime == latestwatchOSRuntime.Identifier && v.SimDeviceType == watchOSDeviceType.Identifier).
|
|
Where ((SimDevice v) => Simulators.AvailableDevicePairs.Any ((pair) => pair.Gizmo == v.UDID)). // filter to watch devices that exists in a device pair
|
|
First ();
|
|
runtasks.Add (new RunSimulatorTask (buildTask, device) { Platform = TestPlatform.watchOS, ExecutionResult = TestExecutingResult.Ignored });
|
|
} else {
|
|
var latestiOSRuntime =
|
|
Simulators.SupportedRuntimes.
|
|
Where ((SimRuntime v) => v.Identifier.StartsWith ("com.apple.CoreSimulator.SimRuntime.iOS-", StringComparison.Ordinal)).
|
|
OrderBy ((SimRuntime v) => v.Version).
|
|
Last ();
|
|
|
|
if (fn.EndsWith ("-unified", StringComparison.Ordinal)) {
|
|
runtasks.Add (new RunSimulatorTask (buildTask, Simulators.AvailableDevices.Where ((SimDevice v) => v.SimRuntime == latestiOSRuntime.Identifier && v.SimDeviceType == "com.apple.CoreSimulator.SimDeviceType.iPhone-5").First ()) { Platform = TestPlatform.iOS_Unified32 });
|
|
runtasks.Add (new RunSimulatorTask (buildTask, Simulators.AvailableDevices.Where ((SimDevice v) => v.SimRuntime == latestiOSRuntime.Identifier && v.SimDeviceType == "com.apple.CoreSimulator.SimDeviceType.iPhone-6s").First ()) { Platform = TestPlatform.iOS_Unified64 });
|
|
} else {
|
|
runtasks.Add (new RunSimulatorTask (buildTask, Simulators.AvailableDevices.Where ((SimDevice v) => v.SimRuntime == latestiOSRuntime.Identifier && v.SimDeviceType == "com.apple.CoreSimulator.SimDeviceType.iPhone-4s").First ()) { Platform = TestPlatform.iOS_Classic });
|
|
}
|
|
}
|
|
|
|
return runtasks;
|
|
}
|
|
|
|
static string AddSuffixToPath (string path, string suffix)
|
|
{
|
|
return Path.Combine (Path.GetDirectoryName (path), Path.GetFileNameWithoutExtension (path) + suffix + Path.GetExtension (path));
|
|
}
|
|
|
|
async Task PopulateTasksAsync ()
|
|
{
|
|
// Missing:
|
|
// api-diff
|
|
// msbuild tests
|
|
var runSimulatorTasks = new List<RunSimulatorTask> ();
|
|
|
|
foreach (var project in Harness.IOSTestProjects) {
|
|
if (!project.IsExecutableProject)
|
|
continue;
|
|
|
|
if (!IncludeBcl && project.Path.Contains ("bcl-test"))
|
|
continue;
|
|
|
|
var build = new XBuildTask ()
|
|
{
|
|
Jenkins = this,
|
|
ProjectFile = project.Path,
|
|
ProjectConfiguration = "Debug",
|
|
ProjectPlatform = "iPhoneSimulator",
|
|
Platform = TestPlatform.iOS_Classic,
|
|
};
|
|
if (IncludeClassic)
|
|
runSimulatorTasks.AddRange (await CreateRunSimulatorTaskAsync (build));
|
|
|
|
var suffixes = new string [] { "-unified", "-tvos", "-watchos" };
|
|
foreach (var suffix in suffixes) {
|
|
var derived = new XBuildTask ()
|
|
{
|
|
Jenkins = this,
|
|
ProjectFile = AddSuffixToPath (project.Path, suffix),
|
|
ProjectConfiguration = build.ProjectConfiguration,
|
|
ProjectPlatform = build.ProjectPlatform,
|
|
};
|
|
switch (suffix) {
|
|
case "-unified":
|
|
derived.Platform = TestPlatform.iOS_Unified;
|
|
break;
|
|
case "-tvos":
|
|
derived.Platform = TestPlatform.tvOS;
|
|
break;
|
|
case "-watchos":
|
|
derived.Platform = TestPlatform.watchOS;
|
|
break;
|
|
default:
|
|
throw new NotImplementedException ();
|
|
}
|
|
runSimulatorTasks.AddRange (await CreateRunSimulatorTaskAsync (derived));
|
|
}
|
|
}
|
|
|
|
foreach (var taskGroup in runSimulatorTasks.GroupBy ((RunSimulatorTask task) => task.Device)) {
|
|
Tasks.Add (new AggregatedRunSimulatorTask (taskGroup)
|
|
{
|
|
Jenkins = this,
|
|
Device = taskGroup.Key,
|
|
});
|
|
}
|
|
|
|
foreach (var project in Harness.MacTestProjects) {
|
|
if (!project.IsExecutableProject)
|
|
continue;
|
|
|
|
BuildToolTask build;
|
|
if (project.GenerateVariations) {
|
|
build = new MdtoolTask ();
|
|
build.Platform = TestPlatform.Mac_Classic;
|
|
} else {
|
|
build = new XBuildTask ();
|
|
build.Platform = TestPlatform.Mac;
|
|
}
|
|
build.Jenkins = this;
|
|
build.ProjectFile = project.Path;
|
|
build.ProjectConfiguration = "Debug";
|
|
build.ProjectPlatform = "x86";
|
|
build.SpecifyPlatform = false;
|
|
build.SpecifyConfiguration = false;
|
|
var exec = new MacExecuteTask ()
|
|
{
|
|
Platform = build.Platform,
|
|
Jenkins = this,
|
|
BuildTask = build,
|
|
ProjectFile = build.ProjectFile,
|
|
ProjectConfiguration = build.ProjectConfiguration,
|
|
ProjectPlatform = build.ProjectPlatform,
|
|
};
|
|
Tasks.Add (exec);
|
|
|
|
if (project.GenerateVariations) {
|
|
Tasks.Add (CloneExecuteTask (exec, TestPlatform.Mac_Unified, "-unified"));
|
|
Tasks.Add (CloneExecuteTask (exec, TestPlatform.Mac_UnifiedXM45, "-unifiedXM45"));
|
|
}
|
|
}
|
|
|
|
|
|
foreach (var task in runSimulatorTasks) {
|
|
if (task.TestName == "framework-test")
|
|
task.ExecutionResult = TestExecutingResult.Ignored;
|
|
}
|
|
}
|
|
|
|
static MacExecuteTask CloneExecuteTask (MacExecuteTask task, TestPlatform platform, string suffix)
|
|
{
|
|
var build = new XBuildTask ()
|
|
{
|
|
Platform = platform,
|
|
Jenkins = task.Jenkins,
|
|
ProjectFile = AddSuffixToPath (task.ProjectFile, suffix),
|
|
ProjectConfiguration = task.ProjectConfiguration,
|
|
ProjectPlatform = task.ProjectPlatform,
|
|
SpecifyPlatform = task.BuildTask.SpecifyPlatform,
|
|
SpecifyConfiguration = task.BuildTask.SpecifyConfiguration,
|
|
};
|
|
|
|
var execute = new MacExecuteTask ()
|
|
{
|
|
Platform = build.Platform,
|
|
Jenkins = build.Jenkins,
|
|
ProjectFile = build.ProjectFile,
|
|
ProjectConfiguration = build.ProjectConfiguration,
|
|
ProjectPlatform = build.ProjectPlatform,
|
|
BuildTask = build,
|
|
};
|
|
|
|
return execute;
|
|
}
|
|
|
|
public int Run ()
|
|
{
|
|
try {
|
|
Directory.CreateDirectory (LogDirectory);
|
|
Harness.HarnessLog = Logs.Create (LogDirectory, "Harness.log", "Harness log");
|
|
Task.Run (async () =>
|
|
{
|
|
await PopulateTasksAsync ();
|
|
}).Wait ();
|
|
var tasks = new List<Task> ();
|
|
foreach (var task in Tasks)
|
|
tasks.Add (task.RunAsync ());
|
|
Task.WaitAll (tasks.ToArray ());
|
|
GenerateReport ();
|
|
return Tasks.Any ((v) => v.ExecutionResult == TestExecutingResult.Failed || v.ExecutionResult == TestExecutingResult.Crashed) ? 1 : 0;
|
|
} catch (Exception ex) {
|
|
Harness.Log ("Unexpected exception: {0}", ex);
|
|
return 2;
|
|
}
|
|
}
|
|
|
|
string GetTestColor (IEnumerable<TestTask> tests)
|
|
{
|
|
if (tests.All ((v) => v.Succeeded))
|
|
return "green";
|
|
else if (tests.Any ((v) => v.Crashed))
|
|
return "maroon";
|
|
else if (tests.Any ((v) => v.TimedOut))
|
|
return "purple";
|
|
else if (tests.Any ((v) => v.BuildFailure))
|
|
return "darkred";
|
|
else if (tests.Any ((v) => v.Failed))
|
|
return "red";
|
|
else if (tests.All ((v) => v.Building))
|
|
return "darkblue";
|
|
else if (tests.All ((v) => v.InProgress))
|
|
return "blue";
|
|
else if (tests.Any ((v) => v.NotStarted))
|
|
return "black";
|
|
else if (tests.Any ((v) => v.Ignored))
|
|
return "gray";
|
|
else
|
|
return "black";
|
|
}
|
|
|
|
string GetTestColor (TestTask test)
|
|
{
|
|
if (test.NotStarted) {
|
|
return "black";
|
|
} else if (test.InProgress) {
|
|
if (test.Building) {
|
|
return "darkblue";
|
|
} else if (test.Running) {
|
|
return "lightblue";
|
|
} else {
|
|
return "blue";
|
|
}
|
|
} else {
|
|
if (test.Crashed) {
|
|
return "maroon";
|
|
} else if (test.HarnessException) {
|
|
return "yellow";
|
|
} else if (test.TimedOut) {
|
|
return "purple";
|
|
} else if (test.BuildFailure) {
|
|
return "darkred";
|
|
} else if (test.Failed) {
|
|
return "red";
|
|
} else if (test.Succeeded) {
|
|
return "green";
|
|
} else if (test.Ignored) {
|
|
return "gray";
|
|
} else {
|
|
return "pink";
|
|
}
|
|
}
|
|
}
|
|
|
|
object report_lock = new object ();
|
|
public void GenerateReport ()
|
|
{
|
|
var id_counter = 0;
|
|
using (var stream = new MemoryStream ()) {
|
|
using (var writer = new StreamWriter (stream)) {
|
|
writer.WriteLine ("<!DOCTYPE html>");
|
|
writer.WriteLine ("<html>");
|
|
writer.WriteLine ("<title>Test results</title>");
|
|
writer.WriteLine (@"<script type='text/javascript'>
|
|
function toggleLogVisibility (logName)
|
|
{
|
|
var button = document.getElementById ('button_' + logName);
|
|
var logs = document.getElementById ('logs_' + logName);
|
|
if (logs.style.display == 'none') {
|
|
logs.style.display = 'block';
|
|
button.innerText = 'Hide details';
|
|
} else {
|
|
logs.style.display = 'none';
|
|
button.innerText = 'Show details';
|
|
}
|
|
}
|
|
function toggleContainerVisibility (containerName)
|
|
{
|
|
var button = document.getElementById ('button_container_' + containerName);
|
|
var div = document.getElementById ('test_container_' + containerName);
|
|
if (div.style.display == 'none') {
|
|
div.style.display = 'block';
|
|
button.innerText = 'Hide';
|
|
} else {
|
|
div.style.display = 'none';
|
|
button.innerText = 'Show';
|
|
}
|
|
}
|
|
</script>");
|
|
writer.WriteLine ("<body>");
|
|
writer.WriteLine ("<h1>Test results</h1>");
|
|
|
|
foreach (var log in Logs)
|
|
writer.WriteLine ("<a href='{0}' type='text/plain'>{1}</a><br />", log.Path.Substring (LogDirectory.Length + 1), log.Description);
|
|
|
|
var allSimulatorTasks = new List<RunSimulatorTask> ();
|
|
var allExecuteTasks = new List<MacExecuteTask> ();
|
|
foreach (var task in Tasks) {
|
|
var aggregated = task as AggregatedRunSimulatorTask;
|
|
if (aggregated != null) {
|
|
allSimulatorTasks.AddRange (aggregated.Tasks);
|
|
continue;
|
|
}
|
|
|
|
var execute = task as MacExecuteTask;
|
|
if (execute != null) {
|
|
allExecuteTasks.Add (execute);
|
|
continue;
|
|
}
|
|
|
|
throw new NotImplementedException ();
|
|
}
|
|
|
|
var allTasks = new List<TestTask> ();
|
|
allTasks.AddRange (allExecuteTasks);
|
|
allTasks.AddRange (allSimulatorTasks);
|
|
|
|
var failedTests = allTasks.Where ((v) => v.Failed);
|
|
var stillInProgress = allTasks.Any ((v) => v.InProgress);
|
|
if (failedTests.Count () == 0) {
|
|
if (stillInProgress) {
|
|
writer.WriteLine ("<h2>All tests passed (but still tests in progress)</h2>");
|
|
} else {
|
|
writer.WriteLine ("<h2 style='color: green'>All tests passed</h2>");
|
|
}
|
|
} else {
|
|
writer.WriteLine ("<h2 style='color: red'>{0} tests failed</h2>", failedTests.Count ());
|
|
foreach (var group in failedTests.GroupBy ((v) => v.TestName)) {
|
|
var enumerableGroup = group as IEnumerable<TestTask>;
|
|
if (enumerableGroup != null) {
|
|
writer.WriteLine ("<a href='#test_{2}'>{0}</a> ({1})<br />", group.Key, string.Join (", ", enumerableGroup.Select ((v) => string.Format ("<span style='color: {0}'>{1}</span>", GetTestColor (v), string.IsNullOrEmpty (v.Mode) ? v.ExecutionResult.ToString () : v.Mode)).ToArray ()), group.Key.Replace (' ', '-'));
|
|
continue;
|
|
}
|
|
|
|
//var executionGroup = group as IEnumerable<MacExecuteTask>;
|
|
//if (executionGroup != null) {
|
|
// writer.WriteLine ("<a href='#test_{2}'>{0}</a> ({1})<br />", group.Key, string.Join (", ", executionGroup.Select ((v) => string.Format ("<span style='color: {0}'>{1}</span>", GetTestColor (v), v.Mode)).ToArray ()), group.Key.Replace (' ', '-'));
|
|
// continue;
|
|
//}
|
|
|
|
throw new NotImplementedException ();
|
|
}
|
|
}
|
|
|
|
//foreach (var group in allExecuteTasks.GroupBy ((MacExecuteTask v) => v.TestName)) {
|
|
|
|
//}
|
|
|
|
foreach (var group in allTasks.GroupBy ((TestTask v) => v.TestName)) {
|
|
var firstResult = group.First ().ExecutionResult;
|
|
var identicalResults = group.All ((v) => v.ExecutionResult == firstResult);
|
|
var defaultHide = !group.Any ((v) => v.Failed);
|
|
writer.WriteLine ("<h2 id='test_{1}'>{0} (<span style='color: {2}'>{4}</span>) <small><a id='button_container_{1}' href=\"javascript: toggleContainerVisibility ('{1}');\">{3}</a></small> </h2>",
|
|
group.Key, group.Key.Replace (' ', '-'), GetTestColor (group), defaultHide ? "Show" : "Hide", identicalResults ? firstResult.ToString () : "multiple results");
|
|
writer.WriteLine ("<div id='test_container_{0}' style='display: {1}'>", group.Key.Replace (' ', '-'), defaultHide ? "none" : "block");
|
|
foreach (var test in group) {
|
|
string state;
|
|
state = test.ExecutionResult.ToString ();
|
|
var log_id = id_counter++;
|
|
writer.WriteLine ("{0} (<span style='color: {3}'>{1}</span>) <a id='button_{2}' href=\"javascript: toggleLogVisibility ('{2}');\">Show details</a><br />", test.Mode, state, log_id, GetTestColor (test));
|
|
writer.WriteLine ("<div id='logs_{0}' style='display: none; padding-bottom: 10px; padding-top: 10px; padding-left: 20px;'>", log_id);
|
|
writer.WriteLine ("Duration: {0} <br />", test.Duration);
|
|
var logs = test.AggregatedLogs;
|
|
if (logs.Count () > 0) {
|
|
foreach (var log in logs) {
|
|
writer.WriteLine ("<a href='{0}' type='text/plain'>{1}</a><br />", log.Path.Substring (LogDirectory.Length + 1), log.Description);
|
|
if (log.Description == "Test log") {
|
|
var summary = string.Empty;
|
|
try {
|
|
if (File.Exists (log.Path)) {
|
|
using (var fs = new FileStream (log.Path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) {
|
|
using (var reader = new StreamReader (fs)) {
|
|
while (!reader.EndOfStream) {
|
|
string line = reader.ReadLine ();
|
|
if (line.StartsWith ("Tests run:", StringComparison.Ordinal)) {
|
|
summary = line;
|
|
} else if (line.Trim ().StartsWith ("[FAIL]", StringComparison.Ordinal)) {
|
|
writer.WriteLine ("<span style='padding-left: 20px;'>{0}</span><br />", line.Trim ());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
summary = "No test log (yet).";
|
|
}
|
|
if (!string.IsNullOrEmpty (summary))
|
|
writer.WriteLine ("<span style='padding-left: 15px;'>{0}</span><br />", summary);
|
|
} catch (Exception ex) {
|
|
writer.WriteLine ("<span style='padding-left: 15px;'>Could not parse log file: {0}</span><br />", System.Web.HttpUtility.HtmlEncode (ex.Message));
|
|
}
|
|
} else if (log.Description == "Build log") {
|
|
var errors = new HashSet<string> ();
|
|
try {
|
|
if (File.Exists (log.Path)) {
|
|
using (var fs = new FileStream (log.Path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) {
|
|
using (var reader = new StreamReader (fs)) {
|
|
while (!reader.EndOfStream) {
|
|
string line = reader.ReadLine ().Trim ();
|
|
if (line.Contains (": error"))
|
|
errors.Add (line);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
errors.Add ("Log file doesn't exist (yet)");
|
|
}
|
|
foreach (var error in errors)
|
|
writer.WriteLine ("<span style='padding-left: 15\tpx;'>{0}</span> <br />", error);
|
|
} catch (Exception ex) {
|
|
writer.WriteLine ("<span style='padding-left: 15px;'>Could not parse log file: {0}</span><br />", System.Web.HttpUtility.HtmlEncode (ex.Message));
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
writer.WriteLine ("No logs<br />");
|
|
}
|
|
writer.WriteLine ("</div>");
|
|
}
|
|
writer.WriteLine ("</div>");
|
|
}
|
|
writer.WriteLine ("</body>");
|
|
writer.WriteLine ("</html>");
|
|
}
|
|
lock (report_lock) {
|
|
var report = Path.Combine (LogDirectory, "index.html");
|
|
if (File.Exists (report))
|
|
File.Delete (report);
|
|
File.WriteAllBytes (report, stream.ToArray ());
|
|
Harness.Log (2, "Generated report: {0}", report);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
abstract class TestTask
|
|
{
|
|
public Jenkins Jenkins;
|
|
public Harness Harness { get { return Jenkins.Harness; } }
|
|
public string ProjectFile;
|
|
public string ProjectConfiguration;
|
|
public string ProjectPlatform;
|
|
|
|
Stopwatch duration = new Stopwatch ();
|
|
public TimeSpan Duration {
|
|
get {
|
|
return duration.Elapsed;
|
|
}
|
|
}
|
|
|
|
TestExecutingResult execution_result;
|
|
public TestExecutingResult ExecutionResult {
|
|
get {
|
|
return execution_result;
|
|
}
|
|
set {
|
|
execution_result = value;
|
|
Jenkins.GenerateReport ();
|
|
}
|
|
}
|
|
|
|
public bool NotStarted { get { return (ExecutionResult & TestExecutingResult.StateMask) == TestExecutingResult.NotStarted; } }
|
|
public bool InProgress { get { return (ExecutionResult & TestExecutingResult.StateMask) == TestExecutingResult.InProgress; } }
|
|
public bool Finished { get { return (ExecutionResult & TestExecutingResult.StateMask) == TestExecutingResult.Finished; } }
|
|
|
|
public bool Building { get { return (ExecutionResult & TestExecutingResult.InProgressMask) == TestExecutingResult.Building; } }
|
|
public bool Built { get { return (ExecutionResult & TestExecutingResult.InProgressMask) == TestExecutingResult.Built; } }
|
|
public bool Running { get { return (ExecutionResult & TestExecutingResult.InProgressMask) == TestExecutingResult.Running; } }
|
|
|
|
public bool Succeeded { get { return (ExecutionResult & TestExecutingResult.Succeeded) == TestExecutingResult.Succeeded; } }
|
|
public bool Failed { get { return (ExecutionResult & TestExecutingResult.Failed) == TestExecutingResult.Failed; } }
|
|
public bool Ignored { get { return (ExecutionResult & TestExecutingResult.Ignored) == TestExecutingResult.Ignored; } }
|
|
|
|
public bool Crashed { get { return (ExecutionResult & TestExecutingResult.Crashed) == TestExecutingResult.Crashed; } }
|
|
public bool TimedOut { get { return (ExecutionResult & TestExecutingResult.TimedOut) == TestExecutingResult.TimedOut; } }
|
|
public bool BuildFailure { get { return (ExecutionResult & TestExecutingResult.BuildFailure) == TestExecutingResult.BuildFailure; } }
|
|
public bool HarnessException { get { return (ExecutionResult & TestExecutingResult.HarnessException) == TestExecutingResult.HarnessException; } }
|
|
|
|
public virtual string Mode { get; set; }
|
|
|
|
public virtual string TestName {
|
|
get {
|
|
var rv = Path.GetFileNameWithoutExtension (ProjectFile);
|
|
switch (Platform) {
|
|
case TestPlatform.Mac:
|
|
case TestPlatform.Mac_Classic:
|
|
return rv;
|
|
case TestPlatform.Mac_Unified:
|
|
return rv.Substring (0, rv.Length - "-unified".Length);
|
|
case TestPlatform.Mac_UnifiedXM45:
|
|
return rv.Substring (0, rv.Length - "-unifiedXM45".Length);
|
|
default:
|
|
if (rv.EndsWith ("-watchos", StringComparison.Ordinal)) {
|
|
return rv.Substring (0, rv.Length - 8);
|
|
} else if (rv.EndsWith ("-tvos", StringComparison.Ordinal)) {
|
|
return rv.Substring (0, rv.Length - 5);
|
|
} else if (rv.EndsWith ("-unified", StringComparison.Ordinal)) {
|
|
return rv.Substring (0, rv.Length - 8);
|
|
} else {
|
|
return rv;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public TestPlatform Platform { get; set; }
|
|
|
|
public LogFiles Logs = new LogFiles ();
|
|
public List<Resource> Resources = new List<Resource> ();
|
|
|
|
public virtual IEnumerable<LogFile> AggregatedLogs {
|
|
get {
|
|
return Logs;
|
|
}
|
|
}
|
|
|
|
public string LogDirectory {
|
|
get {
|
|
return Path.Combine (Jenkins.LogDirectory, TestName);
|
|
}
|
|
}
|
|
|
|
Task build_task;
|
|
async Task RunInternalAsync ()
|
|
{
|
|
if (Finished)
|
|
return;
|
|
|
|
ExecutionResult = (ExecutionResult & ~TestExecutingResult.StateMask) | TestExecutingResult.InProgress;
|
|
|
|
Jenkins.GenerateReport ();
|
|
|
|
duration.Start ();
|
|
|
|
build_task = ExecuteAsync ();
|
|
await build_task;
|
|
|
|
duration.Stop ();
|
|
|
|
ExecutionResult = (ExecutionResult & ~TestExecutingResult.StateMask) | TestExecutingResult.Finished;
|
|
if ((ExecutionResult & ~TestExecutingResult.StateMask) == 0)
|
|
throw new Exception ("Result not set!");
|
|
|
|
Jenkins.GenerateReport ();
|
|
}
|
|
|
|
public Task RunAsync ()
|
|
{
|
|
if (build_task == null)
|
|
build_task = RunInternalAsync ();
|
|
return build_task;
|
|
}
|
|
|
|
protected abstract Task ExecuteAsync ();
|
|
|
|
public override string ToString ()
|
|
{
|
|
return ExecutionResult.ToString ();
|
|
}
|
|
}
|
|
|
|
abstract class BuildToolTask : TestTask
|
|
{
|
|
public bool SpecifyPlatform = true;
|
|
public bool SpecifyConfiguration = true;
|
|
|
|
public override string Mode {
|
|
get { return Platform.ToString (); }
|
|
set { throw new NotSupportedException (); }
|
|
}
|
|
|
|
protected void SetEnvironmentVariables (Process process)
|
|
{
|
|
switch (Platform) {
|
|
case TestPlatform.iOS_Classic:
|
|
case TestPlatform.iOS_Unified:
|
|
case TestPlatform.iOS_Unified32:
|
|
case TestPlatform.iOS_Unified64:
|
|
case TestPlatform.tvOS:
|
|
case TestPlatform.watchOS:
|
|
process.StartInfo.EnvironmentVariables ["MD_APPLE_SDK_ROOT"] = Harness.XcodeRoot;
|
|
process.StartInfo.EnvironmentVariables ["MD_MTOUCH_SDK_ROOT"] = Path.Combine (Harness.IOS_DESTDIR, "Library", "Frameworks", "Xamarin.iOS.framework", "Versions", "Current");
|
|
process.StartInfo.EnvironmentVariables ["XBUILD_FRAMEWORK_FOLDERS_PATH"] = Path.Combine (Harness.IOS_DESTDIR, "Library", "Frameworks", "Mono.framework", "External", "xbuild-frameworks");
|
|
process.StartInfo.EnvironmentVariables ["MSBuildExtensionsPath"] = Path.Combine (Harness.IOS_DESTDIR, "Library", "Frameworks", "Mono.framework", "External", "xbuild");
|
|
break;
|
|
case TestPlatform.Mac:
|
|
case TestPlatform.Mac_Classic:
|
|
case TestPlatform.Mac_Unified:
|
|
case TestPlatform.Mac_UnifiedXM45:
|
|
process.StartInfo.EnvironmentVariables ["MD_APPLE_SDK_ROOT"] = Harness.XcodeRoot;
|
|
process.StartInfo.EnvironmentVariables ["XBUILD_FRAMEWORK_FOLDERS_PATH"] = Path.Combine (Harness.MAC_DESTDIR, "Library", "Frameworks", "Mono.framework", "External", "xbuild-frameworks");
|
|
process.StartInfo.EnvironmentVariables ["MSBuildExtensionsPath"] = Path.Combine (Harness.MAC_DESTDIR, "Library", "Frameworks", "Mono.framework", "External", "xbuild");
|
|
process.StartInfo.EnvironmentVariables ["XamarinMacFrameworkRoot"] = Path.Combine (Harness.MAC_DESTDIR, "Library", "Frameworks", "Xamarin.Mac.framework", "Versions", "Current");
|
|
process.StartInfo.EnvironmentVariables ["XAMMAC_FRAMEWORK_PATH"] = Path.Combine (Harness.MAC_DESTDIR, "Library", "Frameworks", "Xamarin.Mac.framework", "Versions", "Current");
|
|
break;
|
|
default:
|
|
throw new NotImplementedException ();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
class MdtoolTask : BuildToolTask
|
|
{
|
|
protected override async Task ExecuteAsync ()
|
|
{
|
|
using (var resource = await Jenkins.DesktopResource.AcquireConcurrentAsync ()) {
|
|
using (var xbuild = new Process ()) {
|
|
xbuild.StartInfo.FileName = "/Applications/Xamarin Studio.app/Contents/MacOS/mdtool";
|
|
var args = new StringBuilder ();
|
|
args.Append ("build ");
|
|
var sln = Path.ChangeExtension (ProjectFile, "sln");
|
|
args.Append (Harness.Quote (File.Exists (sln) ? sln : ProjectFile));
|
|
xbuild.StartInfo.Arguments = args.ToString ();
|
|
Harness.Log ("Building {0} ({1})", TestName, Mode);
|
|
SetEnvironmentVariables (xbuild);
|
|
var log = Logs.Create (LogDirectory, "build-" + Platform + ".txt", "Build log");
|
|
foreach (string key in xbuild.StartInfo.EnvironmentVariables.Keys)
|
|
log.WriteLine ("{0}={1}", key, xbuild.StartInfo.EnvironmentVariables [key]);
|
|
log.WriteLine ("{0} {1}", xbuild.StartInfo.FileName, xbuild.StartInfo.Arguments);
|
|
if (Harness.DryRun) {
|
|
Harness.Log ("{0} {1}", xbuild.StartInfo.FileName, xbuild.StartInfo.Arguments);
|
|
} else {
|
|
try {
|
|
await xbuild.RunAsync (log.Path, true, TimeSpan.FromMinutes (5));
|
|
ExecutionResult = xbuild.ExitCode == 0 ? TestExecutingResult.Succeeded : TestExecutingResult.Failed;
|
|
} catch (TimeoutException e) {
|
|
log.WriteLine ("Build timed out after {0} seconds.", e.Timeout.TotalSeconds);
|
|
ExecutionResult = TestExecutingResult.TimedOut;
|
|
} catch (Exception e) {
|
|
log.WriteLine ("Harness exception: {0}", e);
|
|
ExecutionResult = TestExecutingResult.HarnessException;
|
|
}
|
|
}
|
|
Harness.Log ("Built {0} ({1})", TestName, Mode);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class XBuildTask : BuildToolTask
|
|
{
|
|
protected override async Task ExecuteAsync ()
|
|
{
|
|
using (var resource = await Jenkins.DesktopResource.AcquireConcurrentAsync ()) {
|
|
using (var xbuild = new Process ()) {
|
|
xbuild.StartInfo.FileName = "xbuild";
|
|
var args = new StringBuilder ();
|
|
args.Append ("/verbosity:diagnostic ");
|
|
if (SpecifyPlatform)
|
|
args.Append ($"/p:Platform={ProjectPlatform} ");
|
|
if (SpecifyConfiguration)
|
|
args.Append ($"/p:Configuration={ProjectConfiguration} ");
|
|
args.Append (Harness.Quote (ProjectFile));
|
|
xbuild.StartInfo.Arguments = args.ToString ();
|
|
Harness.Log ("Building {0} ({1})", TestName, Mode);
|
|
SetEnvironmentVariables (xbuild);
|
|
var log = Logs.Create (LogDirectory, "build-" + Platform + ".txt", "Build log");
|
|
foreach (string key in xbuild.StartInfo.EnvironmentVariables.Keys)
|
|
log.WriteLine ("{0}={1}", key, xbuild.StartInfo.EnvironmentVariables [key]);
|
|
log.WriteLine ("{0} {1}", xbuild.StartInfo.FileName, xbuild.StartInfo.Arguments);
|
|
if (Harness.DryRun) {
|
|
Harness.Log ("{0} {1}", xbuild.StartInfo.FileName, xbuild.StartInfo.Arguments);
|
|
} else {
|
|
try {
|
|
await xbuild.RunAsync (log.Path, true, TimeSpan.FromMinutes (5));
|
|
ExecutionResult = xbuild.ExitCode == 0 ? TestExecutingResult.Succeeded : TestExecutingResult.Failed;
|
|
} catch (TimeoutException e) {
|
|
log.WriteLine ("Build timed out after {0} seconds.", e.Timeout.TotalSeconds);
|
|
ExecutionResult = TestExecutingResult.TimedOut;
|
|
} catch (Exception e) {
|
|
log.WriteLine ("Harness exception: {0}", e);
|
|
ExecutionResult = TestExecutingResult.HarnessException;
|
|
}
|
|
}
|
|
Harness.Log ("Built {0} ({1})", TestName, Mode);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
abstract class MacTask : TestTask
|
|
{
|
|
public override string Mode {
|
|
get {
|
|
switch (Platform) {
|
|
case TestPlatform.Mac:
|
|
return TestName;
|
|
case TestPlatform.Mac_Classic:
|
|
return "Classic";
|
|
case TestPlatform.Mac_Unified:
|
|
return "Unified";
|
|
case TestPlatform.Mac_UnifiedXM45:
|
|
return "Unified XM45";
|
|
default:
|
|
throw new NotImplementedException ();
|
|
}
|
|
}
|
|
set {
|
|
throw new NotSupportedException ();
|
|
}
|
|
}
|
|
}
|
|
|
|
class MacExecuteTask : MacTask
|
|
{
|
|
public string Path;
|
|
public BuildToolTask BuildTask;
|
|
|
|
public override IEnumerable<LogFile> AggregatedLogs {
|
|
get {
|
|
return base.AggregatedLogs.Union (BuildTask.Logs);
|
|
}
|
|
}
|
|
|
|
protected override async Task ExecuteAsync ()
|
|
{
|
|
ExecutionResult = TestExecutingResult.Building;
|
|
await BuildTask.RunAsync ();
|
|
if (!BuildTask.Succeeded) {
|
|
ExecutionResult = TestExecutingResult.BuildFailure;
|
|
return;
|
|
}
|
|
|
|
ExecutionResult = TestExecutingResult.Built;
|
|
|
|
var projectDir = System.IO.Path.GetDirectoryName (ProjectFile);
|
|
var name = System.IO.Path.GetFileName (projectDir);
|
|
if (string.Equals ("mac", name, StringComparison.OrdinalIgnoreCase))
|
|
name = System.IO.Path.GetFileName (System.IO.Path.GetDirectoryName (projectDir));
|
|
var suffix = string.Empty;
|
|
switch (Platform) {
|
|
case TestPlatform.Mac_Unified:
|
|
suffix = "-unified";
|
|
break;
|
|
case TestPlatform.Mac_UnifiedXM45:
|
|
suffix = "-unifiedXM45";
|
|
break;
|
|
}
|
|
Path = System.IO.Path.Combine (System.IO.Path.GetDirectoryName (ProjectFile), "bin", BuildTask.ProjectPlatform, BuildTask.ProjectConfiguration + suffix, name + ".app", "Contents", "MacOS", name);
|
|
|
|
using (var resource = await Jenkins.DesktopResource.AcquireConcurrentAsync ()) {
|
|
using (var proc = new Process ()) {
|
|
proc.StartInfo.FileName = Path;
|
|
Harness.Log ("Executing {0} ({1})", TestName, Mode);
|
|
var log = Logs.Create (LogDirectory, "execute-" + Platform + ".txt", "Execution log");
|
|
log.WriteLine ("{0} {1}", proc.StartInfo.FileName, proc.StartInfo.Arguments);
|
|
if (Harness.DryRun) {
|
|
Harness.Log ("{0} {1}", proc.StartInfo.FileName, proc.StartInfo.Arguments);
|
|
} else {
|
|
ExecutionResult = TestExecutingResult.Running;
|
|
try {
|
|
await proc.RunAsync (log.Path, true, TimeSpan.FromMinutes (5));
|
|
ExecutionResult = proc.ExitCode == 0 ? TestExecutingResult.Succeeded : TestExecutingResult.Failed;
|
|
} catch (TimeoutException e) {
|
|
log.WriteLine ("Execution timed out after {0} seconds.", e.Timeout.TotalSeconds);
|
|
ExecutionResult = TestExecutingResult.TimedOut;
|
|
} catch (Exception e) {
|
|
log.WriteLine (e.ToString ());
|
|
ExecutionResult = TestExecutingResult.HarnessException;
|
|
}
|
|
}
|
|
Harness.Log ("Executed {0} ({1})", TestName, Mode);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class RunSimulatorTask : TestTask
|
|
{
|
|
public SimDevice Device;
|
|
public XBuildTask BuildTask;
|
|
public string AppRunnerTarget;
|
|
|
|
AppRunner runner;
|
|
|
|
public async Task BuildAsync ()
|
|
{
|
|
if (Finished)
|
|
return;
|
|
ExecutionResult |= TestExecutingResult.Building;
|
|
await BuildTask.RunAsync ();
|
|
if (BuildTask.Succeeded) {
|
|
ExecutionResult = (ExecutionResult & ~TestExecutingResult.InProgressMask) | TestExecutingResult.Built;
|
|
} else {
|
|
ExecutionResult = (ExecutionResult & ~(TestExecutingResult.InProgressMask | TestExecutingResult.StateMask)) | TestExecutingResult.BuildFailure;
|
|
}
|
|
}
|
|
|
|
public override IEnumerable<LogFile> AggregatedLogs {
|
|
get {
|
|
return base.AggregatedLogs.Union (BuildTask.Logs);
|
|
}
|
|
}
|
|
|
|
public override string Mode {
|
|
get {
|
|
switch (Platform) {
|
|
case TestPlatform.tvOS:
|
|
case TestPlatform.watchOS:
|
|
return Platform.ToString ();
|
|
case TestPlatform.iOS_Classic:
|
|
return "iOS Classic";
|
|
case TestPlatform.iOS_Unified32:
|
|
return "iOS Unified 32-bits";
|
|
case TestPlatform.iOS_Unified64:
|
|
return "iOS Unified 64-bits";
|
|
case TestPlatform.iOS_Unified:
|
|
if (Jenkins.Simulators.SupportedDeviceTypes.Find ((SimDeviceType v) => v.Identifier == Device.SimDeviceType).Supports64Bits) {
|
|
return "iOS Unified 32-bits";
|
|
} else {
|
|
return "iOS Unified 64-bits";
|
|
}
|
|
default:
|
|
throw new NotImplementedException ();
|
|
}
|
|
}
|
|
set { throw new NotSupportedException (); }
|
|
}
|
|
|
|
public RunSimulatorTask (XBuildTask build_task, SimDevice device)
|
|
{
|
|
BuildTask = build_task;
|
|
Device = device;
|
|
Jenkins = build_task.Jenkins;
|
|
ProjectFile = build_task.ProjectFile;
|
|
|
|
var project = Path.GetFileNameWithoutExtension (ProjectFile);
|
|
if (project.EndsWith ("-tvos", StringComparison.Ordinal)) {
|
|
AppRunnerTarget = "tvos-simulator";
|
|
} else if (project.EndsWith ("-watchos", StringComparison.Ordinal)) {
|
|
AppRunnerTarget = "watchos-simulator";
|
|
} else {
|
|
AppRunnerTarget = "ios-simulator";
|
|
}
|
|
}
|
|
|
|
public Task PrepareSimulatorAsync (bool initialize)
|
|
{
|
|
if (Finished)
|
|
return Task.FromResult (true);
|
|
|
|
if (!BuildTask.Succeeded) {
|
|
ExecutionResult = TestExecutingResult.BuildFailure;
|
|
return Task.FromResult (true);
|
|
}
|
|
|
|
runner = new AppRunner ()
|
|
{
|
|
Harness = Harness,
|
|
ProjectFile = ProjectFile,
|
|
SkipSimulatorSetup = !initialize,
|
|
SkipSimulatorCleanup = !initialize,
|
|
Target = AppRunnerTarget,
|
|
LogDirectory = LogDirectory,
|
|
};
|
|
runner.Simulators = new SimDevice [] { Device };
|
|
runner.Initialize ();
|
|
runner.PrepareSimulator ();
|
|
|
|
return Task.FromResult (true);
|
|
}
|
|
|
|
protected override Task ExecuteAsync ()
|
|
{
|
|
Harness.Log ("Running simulator '{0}' ({2}) for {1}", Device.Name, ProjectFile, Jenkins.Simulators.SupportedRuntimes.Where ((v) => v.Identifier == Device.SimRuntime).First ().Name);
|
|
|
|
if (Finished)
|
|
return Task.FromResult (true);
|
|
|
|
if (Harness.DryRun) {
|
|
Harness.Log ("<running app in simulator>");
|
|
} else {
|
|
try {
|
|
ExecutionResult = (ExecutionResult & ~TestExecutingResult.InProgressMask) | TestExecutingResult.Running;
|
|
Jenkins.GenerateReport ();
|
|
runner.Run ();
|
|
ExecutionResult = runner.Result;
|
|
} catch (Exception ex) {
|
|
Harness.Log ("Test {0} failed: {1}", Path.GetFileName (ProjectFile), ex);
|
|
ExecutionResult = TestExecutingResult.HarnessException;
|
|
}
|
|
Logs.AddRange (runner.Logs);
|
|
}
|
|
|
|
foreach (var log in Logs)
|
|
Console.WriteLine ("Log: {0}: {1}", log.Description, log.Path);
|
|
|
|
return Task.FromResult (true);
|
|
}
|
|
}
|
|
|
|
// This class groups simulator run tasks according to the
|
|
// simulator they'll run from, so that we minimize switching
|
|
// between different simulators (which is slow).
|
|
class AggregatedRunSimulatorTask : TestTask
|
|
{
|
|
public SimDevice Device;
|
|
|
|
public IEnumerable<RunSimulatorTask> Tasks;
|
|
|
|
// Due to parallelization this isn't the same as the sum of the duration for all the build tasks.
|
|
Stopwatch build_timer = new Stopwatch ();
|
|
public TimeSpan BuildDuration { get { return build_timer.Elapsed; } }
|
|
|
|
Stopwatch run_timer = new Stopwatch ();
|
|
public TimeSpan RunDuration { get { return run_timer.Elapsed; } }
|
|
|
|
public AggregatedRunSimulatorTask (IEnumerable<RunSimulatorTask> tasks)
|
|
{
|
|
this.Tasks = tasks;
|
|
}
|
|
|
|
protected override async Task ExecuteAsync ()
|
|
{
|
|
// First build everything. This is required for the run simulator
|
|
// task to properly configure the simulator.
|
|
build_timer.Start ();
|
|
await Task.WhenAll (Tasks.Select ((v) => v.BuildAsync ()).Distinct ());
|
|
build_timer.Stop ();
|
|
|
|
using (var desktop = await Jenkins.DesktopResource.AcquireExclusiveAsync ()) {
|
|
Harness.Log ("Preparing simulator: {0}", Device.Name);
|
|
// We need to set the dialog permissions for all the apps
|
|
// before launching the simulator, because once launched
|
|
// the simulator caches the values in-memory.
|
|
bool first = true;
|
|
foreach (var task in Tasks) {
|
|
await task.PrepareSimulatorAsync (first);
|
|
first = false;
|
|
}
|
|
|
|
run_timer.Start ();
|
|
foreach (var task in Tasks)
|
|
await task.RunAsync ();
|
|
run_timer.Stop ();
|
|
}
|
|
|
|
ExecutionResult = Tasks.Any ((v) => !v.Succeeded) ? TestExecutingResult.Failed : TestExecutingResult.Succeeded;
|
|
}
|
|
}
|
|
|
|
// This is a very simple class to manage the general concept of 'resource'.
|
|
// Performance isn't important, so this is very simple.
|
|
// Currently it's only used to make sure everything that happens on the desktop
|
|
// is serialized (Jenkins.DesktopResource), but in the future the idea is to
|
|
// make each connected device a separate resource, which will make it possible
|
|
// to run tests in parallel across devices (and at the same time use the desktop
|
|
// to build the next test project).
|
|
class Resource
|
|
{
|
|
public string Name;
|
|
ConcurrentQueue<TaskCompletionSource<IDisposable>> queue = new ConcurrentQueue<TaskCompletionSource<IDisposable>> ();
|
|
ConcurrentQueue<TaskCompletionSource<IDisposable>> exclusive_queue = new ConcurrentQueue<TaskCompletionSource<IDisposable>> ();
|
|
int users;
|
|
int max_concurrent_users = 1;
|
|
bool exclusive;
|
|
|
|
|
|
public Resource (string name, int max_concurrent_users = 1)
|
|
{
|
|
this.Name = name;
|
|
this.max_concurrent_users = max_concurrent_users;
|
|
}
|
|
|
|
public Task<IDisposable> AcquireConcurrentAsync ()
|
|
{
|
|
lock (queue) {
|
|
if (!exclusive && users < max_concurrent_users) {
|
|
users++;
|
|
return Task.FromResult<IDisposable> (new AcquiredResource (this));
|
|
} else {
|
|
var tcs = new TaskCompletionSource<IDisposable> (new AcquiredResource (this));
|
|
queue.Enqueue (tcs);
|
|
return tcs.Task;
|
|
}
|
|
}
|
|
}
|
|
|
|
public Task<IDisposable> AcquireExclusiveAsync ()
|
|
{
|
|
lock (queue) {
|
|
if (users == 0) {
|
|
users++;
|
|
exclusive = true;
|
|
return Task.FromResult<IDisposable> (new AcquiredResource (this));
|
|
} else {
|
|
var tcs = new TaskCompletionSource<IDisposable> (new AcquiredResource (this));
|
|
exclusive_queue.Enqueue (tcs);
|
|
return tcs.Task;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Release ()
|
|
{
|
|
TaskCompletionSource<IDisposable> tcs;
|
|
|
|
lock (queue) {
|
|
users--;
|
|
exclusive = false;
|
|
if (queue.TryDequeue (out tcs)) {
|
|
users++;
|
|
tcs.SetResult ((IDisposable) tcs.Task.AsyncState);
|
|
} else if (users == 0 && exclusive_queue.TryDequeue (out tcs)) {
|
|
users++;
|
|
exclusive = true;
|
|
tcs.SetResult ((IDisposable) tcs.Task.AsyncState);
|
|
}
|
|
}
|
|
}
|
|
|
|
class AcquiredResource : IDisposable
|
|
{
|
|
Resource resource;
|
|
|
|
public AcquiredResource (Resource resource)
|
|
{
|
|
this.resource = resource;
|
|
}
|
|
|
|
void IDisposable.Dispose ()
|
|
{
|
|
resource.Release ();
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum TestPlatform
|
|
{
|
|
None,
|
|
|
|
iOS_Classic,
|
|
iOS_Unified,
|
|
iOS_Unified32,
|
|
iOS_Unified64,
|
|
tvOS,
|
|
watchOS,
|
|
|
|
Mac,
|
|
Mac_Classic,
|
|
Mac_Unified,
|
|
Mac_UnifiedXM45,
|
|
}
|
|
|
|
[Flags]
|
|
public enum TestExecutingResult
|
|
{
|
|
NotStarted = 0,
|
|
InProgress = 0x1,
|
|
Finished = 0x2,
|
|
StateMask = NotStarted + InProgress + Finished,
|
|
|
|
// In progress state
|
|
Building = 0x10 + InProgress,
|
|
Built = 0x20 + InProgress,
|
|
Running = 0x40 + InProgress,
|
|
InProgressMask = 0x10 + 0x20 + 0x40,
|
|
|
|
// Finished results
|
|
Succeeded = 0x100 + Finished,
|
|
Failed = 0x200 + Finished,
|
|
Ignored = 0x400 + Finished,
|
|
|
|
// Finished & Failed results
|
|
Crashed = 0x1000 + Failed,
|
|
TimedOut = 0x2000 + Failed,
|
|
HarnessException = 0x4000 + Failed,
|
|
BuildFailure = 0x8000 + Failed,
|
|
}
|
|
}
|
|
|