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