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()); }