public void BTM_AfterBlockingShutdown_UnregistersFromHostEnvironment()
{
var mutex = new object();
IRegisteredObject registeredObject = null;
using (ShimsContext.Create())
{
ShimHostingEnvironment.BehaveAsNotImplemented();
ShimHostingEnvironment.RegisterObjectIRegisteredObject = obj =>
{
lock (mutex)
registeredObject = obj;
};
ShimHostingEnvironment.UnregisterObjectIRegisteredObject = obj =>
{
lock (mutex)
{
Assert.AreSame(registeredObject, obj);
registeredObject = null;
}
};
var instance = new RegisteredTasks();
var mre = new ManualResetEvent(false);
instance.Run(() => mre.WaitOne());
mre.Set();
registeredObject.Stop(true);
lock (mutex)
{
Assert.IsNull(registeredObject);
}
}
}
public void BTM_BlockingShutdown_WaitsForAsyncTaskToExit()
{
var mutex = new object();
IRegisteredObject registeredObject = null;
using (ShimsContext.Create())
{
ShimHostingEnvironment.BehaveAsNotImplemented();
ShimHostingEnvironment.RegisterObjectIRegisteredObject = obj =>
{
lock (mutex)
registeredObject = obj;
};
ShimHostingEnvironment.UnregisterObjectIRegisteredObject = obj =>
{
lock (mutex)
{
Assert.AreSame(registeredObject, obj);
registeredObject = null;
}
};
var instance = new RegisteredTasks();
var tcs = new TaskCompletionSource <object>();
instance.Run(() => tcs.Task);
var task = Task.Run(() => registeredObject.Stop(true));
Assert.IsFalse(task.Wait(300));
lock (mutex)
Assert.IsNotNull(registeredObject);
tcs.TrySetResult(null);
}
}
public void BTM_BeforeShutdown_ShutdownNotSignaled()
{
using (ShimsContext.Create())
{
ShimHostingEnvironment.BehaveAsNotImplemented();
ShimHostingEnvironment.RegisterObjectIRegisteredObject = _ => { };
var instance = new RegisteredTasks();
var mre = new ManualResetEvent(false);
instance.Run(() => mre.WaitOne());
mre.Set();
Assert.IsFalse(instance.Shutdown.IsCancellationRequested);
}
}
public void BTM_RegistersWithHostEnvironment()
{
IRegisteredObject registeredObject = null;
using (ShimsContext.Create())
{
ShimHostingEnvironment.BehaveAsNotImplemented();
ShimHostingEnvironment.RegisterObjectIRegisteredObject = arg => { registeredObject = arg; };
var instance = new RegisteredTasks();
var mre = new ManualResetEvent(false);
instance.Run(() => mre.WaitOne());
mre.Set();
}
Assert.IsNotNull(registeredObject);
}
public void BTM_AfterShutdownRequest_AsyncTaskStillRunning_ShutdownIsSignaled()
{
using (ShimsContext.Create())
{
ShimHostingEnvironment.BehaveAsNotImplemented();
IRegisteredObject registeredObject = null;
ShimHostingEnvironment.RegisterObjectIRegisteredObject = obj => { registeredObject = obj; };
ShimHostingEnvironment.UnregisterObjectIRegisteredObject = _ => { };
var instance = new RegisteredTasks();
var tcs = new TaskCompletionSource <object>();
instance.Run(() => tcs.Task);
registeredObject.Stop(false);
Assert.IsTrue(instance.Shutdown.IsCancellationRequested);
tcs.TrySetResult(null);
}
}
public void BTM_AfterShutdownRequest_SyncTaskStillRunning_ShutdownIsSignaled()
{
using (ShimsContext.Create())
{
ShimHostingEnvironment.BehaveAsNotImplemented();
IRegisteredObject registeredObject = null;
ShimHostingEnvironment.RegisterObjectIRegisteredObject = obj => { registeredObject = obj; };
ShimHostingEnvironment.UnregisterObjectIRegisteredObject = _ => { };
var instance = new RegisteredTasks();
var mre = new ManualResetEvent(false);
instance.Run(() => mre.WaitOne());
registeredObject.Stop(false);
Assert.IsTrue(instance.Shutdown.IsCancellationRequested);
mre.Set();
}
}
public Layer[] Compose(RegisteredTasks map, Identities filter)
{
var allTasks = GetAllTasks(map, filter);
var result = new List<Layer>();
while (allTasks.Any())
{
var layerTasks = allTasks.Where(task => AllDependenciesResolved(map, task.Id, result));
var layer = new Layer(layerTasks.Select(x => new ExecutableWithIdentity(x.Task, x.Id)).ToArray());
if (layer.IsEmpty)
{
throw new Exception(GetErrorMessage(allTasks, result));
}
result.Add(layer);
allTasks = allTasks.Where(item => !layer.Contains(item.Task)).ToList();
}
return result.ToArray();
}
private static List<ExecutableWithIdentity> GetAllTasks(RegisteredTasks map, Identities filter)
{
if (filter.IsEmpty)
{
return map.Transform((id, task) => new ExecutableWithIdentity(task.Task, id)).ToList();
}
List<ExecutableWithIdentity> result = new List<ExecutableWithIdentity>();
Identities currentTasks = filter;
while (true)
{
if (currentTasks.IsEmpty)
{
return result;
}
int oldResultSize = result.Count;
IEnumerable<ExecutableWithIdentity> iterationDependencies = map.Transform(currentTasks, (id, task) => new ExecutableWithIdentity(task.Task, id));
foreach (ExecutableWithIdentity dependency in iterationDependencies)
{
if (!result.Any(x => x.Id == dependency.Id))
{
result.Add(dependency);
}
}
int newResultSize = result.Count;
if (newResultSize == oldResultSize)
{
return result;
}
currentTasks = new Identities(currentTasks
.Items
.SelectMany(task => map[task].Dependencies.Items)
.ToArray());
}
}
private void Awake()
{
try
{
RegisterTasks();
foreach (var taskSettings in Settings.taskRunnerSettings.tasks)
{
Task task = RegisteredTasks.GetTask(taskSettings.taskName);
if (task == null)
{
Debug.LogError($"Task with name {taskSettings.taskName} is not registered in TaskRunner.");
}
task.interval = taskSettings.interval;
StartCoroutine(task.ExecuteTask());
}
}
catch (Exception e)
{
Debug.LogError(e.Message);
}
}
public TaskDefinitionAssertions(RegisteredTasks definitions, string notFoundMessage)
{
_definitions = definitions;
_notFoundMessage = notFoundMessage;
}
public TaskDefinitionAssertions(Identity identity, TaskWithBehaviors taskWithBehaviors, RegisteredTasks definitions)
{
_identity = identity;
_taskWithBehaviors = taskWithBehaviors;
_definitions = definitions;
}
private bool AllDependenciesResolved(RegisteredTasks map, Identity id, IEnumerable<Layer> resolvedLayers)
{
return map[id].Dependencies.Items.All(dependency => DependencyResolved(dependency, resolvedLayers));
}
private void RegisterTasks()
{
RegisteredTasks.Register(new GenerateCoinTask());
}
