public void IteratorDisposedIsTrueOnceDisposed()
{
var iter = new TaskEnumerator <int>(JustOne(), 1);
iter.Dispose();
Assert.IsTrue(iter.Disposed);
}
public void TestToArray()
{
var iter = new TaskEnumerator <int>(CountToThree(), 1);
int[] result = (int[])Scheduler.WaitFor(iter.GetArray());
Assert.AreEqual(new int[] { 1, 2, 3 }, result);
}
public void EnumeratorDisposal()
{
var e = new TestEnumerator();
var iter = TaskEnumerator <object> .FromEnumerator(e, 1);
Scheduler.WaitFor(iter.Fetch());
iter.Dispose();
Assert.IsTrue(e.Disposed);
}
public void TestToArrayOnEmptySequence()
{
var e = new TestEnumerator();
var iter = TaskEnumerator <object> .FromEnumerator(e, 1);
object[] items = (object[])Scheduler.WaitFor(iter.GetArray());
object[] expected = new object[0];
Assert.AreEqual(expected, items);
}
IEnumerator <object> IterationTask(TaskEnumerator <int> iterator, List <int> output)
{
while (!iterator.Disposed)
{
yield return(iterator.Fetch());
foreach (var item in iterator)
{
output.Add(item);
}
}
}
public void IteratorRaisesOnceIteratorIsDisposed()
{
var iter = new TaskEnumerator <int>(JustOne(), 1);
iter.Dispose();
try {
using (var e = iter.CurrentItems) {
var _ = e.Current;
Assert.Fail("e.Current did not throw an InvalidOperationException");
}
} catch (InvalidOperationException) {
}
}
public void Dispose()
{
if (Parent != null)
{
Inner.Dispose();
if (!Parent.Disposed)
{
Parent.ReadyForMore();
}
Parent = null;
}
}
public void TestToArray()
{
var e = CountTo100(Thread.CurrentThread);
var iter = TaskEnumerator <int> .FromEnumerable(e, 1);
int[] items = (int[])Scheduler.WaitFor(iter.GetArray());
int[] expected = new int[100];
for (int i = 0; i < 100; i++)
{
expected[i] = i;
}
Assert.AreEqual(expected, items);
}
public void TestIterateSequence()
{
using (var iter = new TaskEnumerator <int>(CountToThree(), 1)) {
for (int i = 1; i <= 3; i++)
{
Assert.IsFalse(iter.Disposed);
Scheduler.WaitFor(iter.Fetch());
using (var e = iter.CurrentItems) {
Assert.IsTrue(e.MoveNext());
Assert.AreEqual(i, e.Current);
Assert.IsFalse(e.MoveNext());
}
}
}
}
public void IteratorRaisesIfCurrentIsAccessedBeforeInitialMoveNext()
{
var iter = new TaskEnumerator <int>(JustOne(), 1);
Assert.IsFalse(iter.Disposed);
Scheduler.WaitFor(iter.Fetch());
try {
using (var e = iter.CurrentItems) {
var _ = e.Current;
Assert.Fail("e.Current did not throw an InvalidOperationException");
}
} catch (InvalidOperationException) {
}
iter.Dispose();
}
public void YieldStartGetTaskIterator()
{
var e = CountTo100(Thread.CurrentThread);
var iter = TaskEnumerator <int> .FromEnumerable(e, 1);
var output = new List <int>();
var f = Scheduler.Start(IterationTask(iter, output));
Scheduler.WaitFor(f);
int[] expected = new int[100];
for (int i = 0; i < 100; i++)
{
expected[i] = i;
}
Assert.AreEqual(output.ToArray(), expected);
}
public void IteratorFailsMoveNextOnceIterationIsComplete()
{
var iter = new TaskEnumerator <int>(JustOne(), 1);
Assert.IsFalse(iter.Disposed);
Scheduler.WaitFor(iter.Fetch());
using (var e = iter.CurrentItems) {
Assert.IsTrue(e.MoveNext());
Assert.AreEqual(1, e.Current);
Assert.IsFalse(e.MoveNext());
}
Assert.IsFalse(iter.Disposed);
Scheduler.WaitFor(iter.Fetch());
Assert.IsTrue(iter.Disposed);
iter.Dispose();
}
public void TestBufferingPerformance()
{
int[] buf = new int[1024 * 512], copy = null;
for (int i = 0; i < buf.Length; i++)
{
buf[i] = i;
}
for (int bs = 8; bs <= 4096; bs *= 2)
{
long timeStart = Time.Ticks;
using (var iter = TaskEnumerator <int> .FromEnumerator((buf as IEnumerable <int>).GetEnumerator(), bs)) {
copy = (int[])Scheduler.WaitFor(iter.GetArray());
}
long timeEnd = Time.Ticks;
TimeSpan elapsed = new TimeSpan(timeEnd - timeStart);
Console.WriteLine("Took {0:N2} secs with a buffer size of {1}.", elapsed.TotalSeconds, bs);
}
}
public void TestTypeCoercion()
{
var iter = new TaskEnumerator <int>(TwoTypes(), 1);
Assert.IsFalse(iter.Disposed);
Scheduler.WaitFor(iter.Fetch());
using (var e = iter.CurrentItems) {
Assert.IsTrue(e.MoveNext());
Assert.AreEqual(1, e.Current);
}
Assert.IsFalse(iter.Disposed);
try {
Scheduler.WaitFor(iter.Fetch());
Assert.Fail("Fetch did not throw an InvalidCastException");
} catch (FutureException fe) {
Assert.IsInstanceOf <InvalidCastException>(fe.InnerException);
}
iter.Dispose();
}
public Enumerator(TaskEnumerator <T> parent, List <T> .Enumerator inner)
{
Parent = parent;
Inner = inner;
_Ready = false;
}
public FetchThunk(TaskEnumerator <T> enumerator)
{
Enumerator = enumerator;
}
