public void Using <T>([PexAssumeNotNull] IEnumerable <T> begin, [PexAssumeNotNull] IEnumerable <T> rest, bool shouldThrow)
{
var nestedEnumerable = begin;
var exception = new Exception();
if (shouldThrow)
{
nestedEnumerable = nestedEnumerable.Concat(EnumerableEx.Throw <T>(exception));
}
nestedEnumerable = nestedEnumerable.Concat(rest);
var disposeHelper = new DisposeHelper();
var enumerable = EnumerableEx.Using(disposeHelper.Produce, d =>
{
PexAssert.AreEqual(disposeHelper,
d);
return(nestedEnumerable);
});
var enumerator = enumerable.GetEnumerator();
var beginEnumerator = begin.GetEnumerator();
while (beginEnumerator.MoveNext())
{
PexAssert.IsTrue(enumerator.MoveNext());
PexAssert.AreEqual(beginEnumerator.Current, enumerator.Current);
}
if (shouldThrow)
{
try
{
enumerator.MoveNext();
PexAssert.Fail();
}
catch (Exception ex)
{
PexAssert.AreEqual(exception, ex);
}
}
else
{
var restEnumerator = rest.GetEnumerator();
while (restEnumerator.MoveNext())
{
PexAssert.IsTrue(enumerator.MoveNext());
PexAssert.AreEqual(restEnumerator.Current, enumerator.Current);
}
PexAssert.IsFalse(enumerator.MoveNext());
}
PexAssert.IsTrue(disposeHelper.IsDone);
}
public void RepeatEmptyEnumerable <T>([PexAssumeNotNull] T[] value, int count)
{
PexAssume.IsTrue(value.Length == 0);
var enumerable = EnumerableEx.Repeat((IEnumerable <T>)value);
var enumerator = enumerable.GetEnumerator();
enumerator.MoveNext();
PexAssert.Fail();
}
public void CatchDifferentType <T>([PexAssumeNotNull] IEnumerable <T> begin, [PexAssumeNotNull] IEnumerable <T> rest, [PexAssumeNotNull] IEnumerable <T> alternative, bool shouldThrow)
{
var ex = new InvalidOperationException();
var expectedCaughtCount = 0;
var caughtCount = 0;
Func <NotSupportedException, IEnumerable <T> > replacer = x =>
{
caughtCount++;
PexAssert.AreEqual(ex, x);
return(alternative);
};
var start = begin;
if (shouldThrow)
{
start = start.Concat(EnumerableEx.Throw <T>(ex));
}
start = start.Concat(rest);
var enumerable = start.Catch(replacer);
var enumerator = enumerable.GetEnumerator();
var beginEnumerator = begin.GetEnumerator();
while (beginEnumerator.MoveNext())
{
PexAssert.IsTrue(enumerator.MoveNext());
PexAssert.AreEqual(beginEnumerator.Current, enumerator.Current);
}
if (shouldThrow)
{
try
{
enumerator.MoveNext();
PexAssert.Fail();
}
catch (InvalidOperationException ioe)
{
PexAssert.AreEqual(ex, ioe);
}
}
else
{
var restEnumerator = rest.GetEnumerator();
while (restEnumerator.MoveNext())
{
PexAssert.IsTrue(enumerator.MoveNext());
PexAssert.AreEqual(restEnumerator.Current, enumerator.Current);
}
}
PexAssert.IsFalse(enumerator.MoveNext());
PexAssert.AreEqual(expectedCaughtCount, caughtCount);
}
public void Finally <T>([PexAssumeNotNull] IEnumerable <T> begin, [PexAssumeNotNull] IEnumerable <T> rest, bool shouldThrow)
{
var done = false;
var enumerable = begin;
var exception = new Exception();
if (shouldThrow)
{
enumerable = enumerable.Concat(EnumerableEx.Throw <T>(exception));
}
enumerable = enumerable.Concat(rest);
enumerable = enumerable.Finally(() => done = true);
var enumerator = enumerable.GetEnumerator();
var beginEnumerator = begin.GetEnumerator();
while (beginEnumerator.MoveNext())
{
PexAssert.IsTrue(enumerator.MoveNext());
PexAssert.AreEqual(beginEnumerator.Current, enumerator.Current);
}
if (shouldThrow)
{
try
{
enumerator.MoveNext();
PexAssert.Fail();
}
catch (Exception ex)
{
PexAssert.AreEqual(exception, ex);
}
}
else
{
var restEnumerator = rest.GetEnumerator();
while (restEnumerator.MoveNext())
{
PexAssert.IsTrue(enumerator.MoveNext());
PexAssert.AreEqual(restEnumerator.Current, enumerator.Current);
}
PexAssert.IsFalse(enumerator.MoveNext());
}
PexAssert.IsTrue(done);
}
public void Throw <T>([PexAssumeNotNull] Exception exception)
{
var enumerable = EnumerableEx.Throw <T>(exception);
try
{
foreach (var res in enumerable)
{
PexAssert.Fail();
}
PexAssert.Fail();
}
catch (Exception ex)
{
PexAssert.AreEqual(exception, ex);
}
}
