public void Setup(int maxTasksInPool, int tasksToFork) { AtomicInteger atomicVal = new AtomicInteger(); IExecutorService execService = new LimitedTaskExecutorService(maxTasksInPool); ICollection<IFuture<int>> futures = new List<IFuture<int>>(tasksToFork); for (int i = 0; i < tasksToFork; i++) { var task = new FutureTask<int>(CallableUtils.FromFunc(() => { Thread.Yield(); Thread.Sleep(7); int value = atomicVal.IncrementAndGet(); Thread.Yield(); return value; })); IFuture<int> future = execService.submit(task); futures.Add(future); } var results = new List<int>(); foreach (IFuture<int> future in futures) { int value = future.get(); results.Add(value); } results.Sort(); int prevValue = results[0]; Console.WriteLine(prevValue); for (int i = 1; i < results.Count; i++) { Console.WriteLine(results[i]); Assert.AreEqual(prevValue + 1, results[i]); prevValue = results[i]; } Assert.AreEqual(atomicVal.Get(), tasksToFork); }
protected override IEnumerator PurchaseItemByCodeInternal( FutureTask<bool> future, string code, int count) { throw new NotImplementedException(); }
public void CancelButNotInterruptBeforeRun() { FutureTask<string> ft = new FutureTask<string>(new FooCallable1()); Assert.IsTrue(ft.Cancel(false)); ft.Run(); Assert.IsTrue(ft.IsDone); Assert.IsTrue(ft.IsCancelled); }
public void CancelAndInterruptTheRunningTask() { FutureTask<int> ft = new FutureTask<int>(new InmediatlyCallable(13)); ft.Run(); Assert.IsFalse(ft.Cancel(true)); Assert.IsTrue(ft.IsDone); Assert.IsFalse(ft.IsCancelled); }
protected override System.Collections.IEnumerator PurchaseInternal( FutureTask<bool> future, int count) { yield return Yields.WaitForNextPolling(); future.Set(true); yield break; }
public void CancelAndInterruptBeforeRun() { var ft = new FutureTask<string>(new FooCallable1()); ft.Cancel(true); ft.Run(); Assert.IsTrue(ft.IsDone); Assert.IsTrue(ft.IsCancelled); }
public void CancelButNotInterruptBeforeRun() { var ft = new FutureTask <string>(new FooCallable1()); Assert.IsTrue(ft.Cancel(false)); ft.Run(); Assert.IsTrue(ft.IsDone); Assert.IsTrue(ft.IsCancelled); }
protected IEnumerator BoolFutureIntInternal( FutureTask<bool> future, int a) { for (int i = 0; i < a; i++) yield return i; future.Set(true); yield break; }
public void CancelAndInterruptTheRunningTask() { var ft = new FutureTask <int>(new InmediatlyCallable(13)); ft.Run(); Assert.IsFalse(ft.Cancel(true)); Assert.IsTrue(ft.IsDone); Assert.IsFalse(ft.IsCancelled); }
protected override IEnumerator RetrieveItemByCodeInternal( FutureTask<ItemModel> future, string code) { ItemModel item; item = this._domain.ItemModel.Get(); future.Set(item); yield break; }
public void CancelButNotInterruptTheRunningTask() { //The Task takes 5 seconds. FutureTask<string> ft = new FutureTask<string>(new FooCallable1()); Thread t = new Thread(ft.Run); t.Start(); Thread.Sleep(100); Assert.IsTrue(ft.Cancel(false)); //Not interrupt because the task running t.Join(); Assert.IsTrue(ft.IsDone); Assert.IsTrue(ft.IsCancelled); }
public void CancelButNotInterruptTheRunningTask() { //The Task takes 5 seconds. var ft = new FutureTask <string>(new FooCallable1()); var t = new Thread(ft.Run); t.Start(); Thread.Sleep(100); Assert.IsTrue(ft.Cancel(false)); //Not interrupt because the task running t.Join(); Assert.IsTrue(ft.IsDone); Assert.IsTrue(ft.IsCancelled); }
public void IsDoneIsCanceledAndGet() { var ft = new FutureTask <int>(new InmediatlyCallable(13)); Assert.AreEqual(false, ft.IsDone); Assert.AreEqual(false, ft.IsCancelled); ft.Run(); Assert.AreEqual(13, ft.Get()); //The result Assert.AreEqual(true, ft.IsDone); Assert.AreEqual(false, ft.IsCancelled); }
public void IsDoneIsCanceledAndGet() { FutureTask<int> ft = new FutureTask<int>(new InmediatlyCallable(13)); Assert.AreEqual(false, ft.IsDone); Assert.AreEqual(false, ft.IsCancelled); ft.Run(); Assert.AreEqual(13, ft.Get()); //The result Assert.AreEqual(true, ft.IsDone); Assert.AreEqual(false, ft.IsCancelled); }
protected override IEnumerator PurchaseItemByCodeInternal( FutureTask<bool> future, string code, int count) { ItemModel item; { Future<ItemModel> depend; depend = this.RetrieveItemByCode(code); yield return depend; if (future.IsCancelling) yield break; item = depend.Get(); } { Future<bool> depend; depend = item.Purchase(count); yield return depend; if (future.IsCancelling) yield break; future.Set(depend.Get()); } }
protected IEnumerator StringNestedFutureIntIntInternal( FutureTask<string> future, int b, int a) { for (int i = 0; i < b; i++) { yield return "before"; yield return this.BoolFutureInt(a); yield return "after"; } yield return "done"; future.Set("completed"); yield break; }
protected IEnumerator ContinuesInternal( FutureTask<bool> future, int depth, Type exception) { Future<bool> inner; inner = depth <= 0 ? this.Throws(exception) : this.ThrowsWrapper(depth - 1, exception); inner.FutureException += delegate(FutureExceptionEvent @event) { Assert.IsType(exception, @event.Exception); Assert.Equal(inner, @event.Future); return FutureProcess.Continue; }; yield return inner; future.Set(true); yield break; }
protected abstract IEnumerator PurchaseInternal( FutureTask<bool> future, int count);
protected IEnumerator CancellableInternal( FutureTask<string> future, int depth) { if (future.IsCancelling) yield break; yield return depth << 1; if (future.IsCancelling) yield break; yield return (depth << 1) + 1; yield return this.Cancellable(depth + 1); }
protected IEnumerator SetResultCountInternal( FutureTask<string> future, int count) { for (int i = 0; i < count; i++) future.Set(String.Format("count: {0:D}", i + 1)); yield break; }
protected abstract IEnumerator RetrieveItemByCodeInternal( FutureTask<ItemModel> future, string code);
protected override IEnumerator RetrieveItemByCodeInternal( FutureTask<ItemModel> future, string code) { throw new NotImplementedException(); }
protected abstract IEnumerator PurchaseItemByCodeInternal( FutureTask<bool> future, string code, int count);