public async Task PrespoolMaintainOrder()
{
var stopwatch = new Stopwatch();
var taskToPrespool = EnumerableAsync.YieldAsync <Func <int, Task> >(
async(yieldAsync) =>
{
for (int i = 0; i < 100; i++)
{
await Task.Run(() => Thread.Sleep(10));
await yieldAsync(i);
}
return;
});
// Test fails without this line
taskToPrespool = taskToPrespool.PrespoolAsync();
await Task.Run(() => Thread.Sleep(1000));
stopwatch.Start();
int index = -1;
await taskToPrespool.ForAllAsync(
async (i) =>
{
await Task.FromResult(false);
Assert.IsTrue(index < i);
index = i;
});
stopwatch.Stop();
Assert.IsTrue(stopwatch.ElapsedMilliseconds < 500);
}
public async Task EnumerableAsyncBrakedTests()
{
var rand = new Random();
var yieldCount = 0;
var items = EnumerableAsync.YieldAsync <TestDelegateAsync>(
async(yield) =>
{
for (int i = 0; i < 100; i++)
{
yieldCount++;
await yield(i, "foo", new List <int>());
}
});
int count = 0;
var culledItems = items.TakeAsync(50);
await culledItems.ForAllAsync(
async (a, b, c) =>
{
await Task.Run(() => Thread.Sleep(rand.Next() % 20));
count++;
});
Assert.AreEqual(50, count);
Assert.AreEqual(51, yieldCount);
}
public async Task PrespoolAllowsParallel()
{
var stopwatch = new Stopwatch();
stopwatch.Start();
var taskToPrespool = EnumerableAsync.YieldAsync <Func <int, Task> >(
async(yieldAsync) =>
{
var tasks = Enumerable.Range(0, 100).Select(async(i) =>
{
await Task.Run(() => Thread.Sleep(1000));
await yieldAsync(i);
});
await Task.WhenAll(tasks);
return;
});
// Test fails without this line
taskToPrespool = taskToPrespool.PrespoolAsync();
int total = 0;
await taskToPrespool.ForAllAsync(
async (i) =>
{
await Task.FromResult(false);
total += i;
});
stopwatch.Stop();
Assert.IsTrue(stopwatch.ElapsedMilliseconds < 25000);
Assert.AreEqual(4950, total);
}
public async Task EnumerableAsyncGerenicTests()
{
var rand = new Random();
var items = EnumerableAsync.YieldAsync <TestDelegateAsync> (
async(yield) =>
{
for (int i = 0; i < 100; i++)
{
await Task.Run(() => Thread.Sleep(rand.Next() % 20));
var yieldTask = yield(i, "foo", new List <int>());
try
{
await yieldTask;
} catch (Exception ex)
{
throw ex;
}
}
await yield(110, "bar", new List <int>());
await yield(111, "food", new List <int>());
await yield(112, "barf", new List <int>());
});
int count = 0;
await items.ForAllAsync(
async (a, b, c) =>
{
await Task.Run(() => Thread.Sleep(rand.Next() % 30));
await Task.FromResult(true);
count++;
});
Assert.AreEqual(103, count);
}
private IEnumerableAsync <StorageDelegateAsync> FindByParentIdSomeNotFound(Guid parentId)
{
var items = EnumerableAsync.YieldAsync <StorageDelegateAsync>(
async(yield) =>
{
await Task.FromResult(true);
throw new Exception("NotFoundStorage");
});
return(items);
}
private IEnumerableAsync <StorageDelegateAsync> FindByParentId(Guid parentId)
{
var items = EnumerableAsync.YieldAsync <StorageDelegateAsync>(
async(yield) =>
{
var tasks = new List <Task>();
for (int i = 0; i < 100; i++)
{
await yield(i, "foo");
}
await yield(110, "bar");
await yield(111, "food");
await yield(112, "barf");
});
return(items);
}
private IEnumerableAsync <BizObjectInfoDelegateAsync> GetBizObject(Guid parentId)
{
var itemsInStorage = FindByParentId(parentId);
var items = EnumerableAsync.YieldAsync <BizObjectInfoDelegateAsync>(
async(yield) =>
{
await itemsInStorage.ForAllAsync(async(a, b) =>
{
if (a % 5 == 0)
{
return;
}
await yield(a, b, new object());
});
});
return(items);
}
public async Task EnumerableAsyncNotAsyncTests()
{
var items = EnumerableAsync.YieldAsync <TestDelegate>(
async(yield) =>
{
await Task.FromResult(true);
yield(112, "barf", new List <int>());
});
try
{
await items.ForAllAsync(
async (a, b, c) => await Task.FromResult(true));
Assert.Fail("Cannot have non-async IEnumerableAsync delegates");
} catch (ArgumentException ex)
{
Assert.AreEqual(typeof(TestDelegate).FullName, ex.ParamName);
}
}
private async Task <IEnumerableAsync <BizObjectInfoDelegateAsync> > GetBizObjectSomeNotFound(Guid parentId)
{
try
{
var itemsInStorage = FindByParentIdSomeNotFound(parentId);
await itemsInStorage.ForAllAsync((a, b) => Task.FromResult(true));
Assert.Fail();
} catch (Exception ex)
{
Assert.AreEqual("NotFoundStorage", ex.Message);
}
var items = EnumerableAsync.YieldAsync <BizObjectInfoDelegateAsync>(
async(yield) =>
{
await Task.FromResult(true);
throw new Exception("NotFoundBiz");
});
return(items);
}
public async Task IterateAsyncGenericTests()
{
var items = EnumerableAsync.YieldAsync <TestDelegateAsync>(
async(yield) =>
{
Thread.Sleep(1000);
var tasks = new List <Task>();
for (int i = 0; i < 100; i++)
{
var yieldTask = yield(i, "foo", new List <int>());
await yieldTask;
}
});
var results = items.ToEnumerable <TestDelegateAsync, TestDelegateResult <int>, int>(
(a, b, c) =>
{
Thread.Sleep(20);
return(a);
});
Assert.AreEqual(100, results.Count());
}
