public void Defer <T>([PexAssumeNotNull] IEnumerable <T> source)
{
var stateful = default(StatefulEnumerable <T>);
var enumerable = EnumerableEx.Defer(() => { stateful = new StatefulEnumerable <T>(source);
return(stateful); });
PexAssert.IsNull(stateful);
var enumerator = enumerable.GetEnumerator();
PexAssert.IsNotNull(stateful);
var sourceEnumerator = source.GetEnumerator();
var expectedState = new List <EnumerableState>()
{
EnumerableState.Fresh,
EnumerableState.CreatingEnumerator,
EnumerableState.CreatedEnumerator,
EnumerableState.MovingNext
};
if (!sourceEnumerator.MoveNext())
{
PexAssert.IsFalse(enumerator.MoveNext());
expectedState.Add(EnumerableState.AtEnd);
PexAssert.AreElementsEqual(expectedState, stateful.States, (a, b) => object.Equals(a, b));
}
else
{
PexAssert.IsTrue(enumerator.MoveNext());
expectedState.Add(EnumerableState.MovedNext);
PexAssert.AreElementsEqual(expectedState, stateful.States, (a, b) => object.Equals(a, b));
expectedState.Add(EnumerableState.GettingCurrent);
PexAssert.AreEqual(sourceEnumerator.Current, enumerator.Current);
expectedState.Add(EnumerableState.GotCurrent);
PexAssert.AreElementsEqual(expectedState, stateful.States, (a, b) => object.Equals(a, b));
var count = 1;
while (sourceEnumerator.MoveNext())
{
count++;
expectedState.Add(EnumerableState.MovingNext);
PexAssert.IsTrue(enumerator.MoveNext());
expectedState.Add(EnumerableState.MovedNext);
PexAssert.AreElementsEqual(expectedState, stateful.States, (a, b) => object.Equals(a, b));
expectedState.Add(EnumerableState.GettingCurrent);
PexAssert.AreEqual(sourceEnumerator.Current, enumerator.Current);
expectedState.Add(EnumerableState.GotCurrent);
PexAssert.AreElementsEqual(expectedState, stateful.States, (a, b) => object.Equals(a, b));
PexAssert.AreEqual(count, stateful.EnumerationCount);
}
PexAssert.IsFalse(enumerator.MoveNext());
}
}
//check for saved substorage settings removed
public void SubstorageSettingsPUT4([PexAssumeUnderTest] String subName, [PexAssumeUnderTest] String[] name, [PexAssumeUnderTest] Object[] value)
{
PexAssume.IsTrue(name.Length == value.Length);
for (int i = 0; i < value.Length; i++)
{
PexAssume.IsTrue(value[i] is bool || value[i] is String || value[i] is int);
PexAssume.IsNotNullOrEmpty(name[i]);
PexAssume.IsNotNull(value[i]);
if (value[i] is String)
{
PexAssume.IsTrue(name[i].Contains(".") || !name[i].Contains("."));
}
}
for (int i = 0; i < name.Length; i++)
{
PexAssume.IsNotNullOrEmpty(name[i]);
}
ISettingsStorage sub = storage.MakeChildStorage(subName);
for (int j = 0; j < value.Length - 1; j++)
{
sub.SaveSetting(name[j], value[j]);
}
for (int j = 0; j < value.Length - 1; j++)
{
String curr = name[j];
sub.RemoveSetting(curr);
PexAssert.IsNull(sub.GetSetting(curr), curr + " not removed");
}
if (name.Length > 0)
{
PexAssert.AreEqual(null, storage.GetSetting(name[name.Length - 1]));
}
}
public void MemoizeWithBufferSizeZero()
{
var source = Enumerable.Range(0, 10);
var x = new List <int>();
var enumerable = source.Do(x.Add).Memoize(0);
var firstEnumerator = enumerable.GetEnumerator();
for (var i = 0; i < 5; i++)
{
PexAssert.IsTrue(firstEnumerator.MoveNext());
PexAssert.AreEqual(i, firstEnumerator.Current);
}
var secondEnumerator = enumerable.GetEnumerator();
for (var i = 0; i < 5; i++)
{
PexAssert.IsTrue(secondEnumerator.MoveNext());
PexAssert.AreEqual(i + 5, secondEnumerator.Current);
}
for (var i = 0; i < 5; i++)
{
PexAssert.IsTrue(firstEnumerator.MoveNext());
PexAssert.AreEqual(i + 5, firstEnumerator.Current);
}
PexAssert.AreElementsEqual(x, Enumerable.Range(0, 10), (a, b) => object.Equals(a, b));
var thirdEnumerator = enumerable.GetEnumerator();
PexAssert.IsFalse(thirdEnumerator.MoveNext());
PexAssert.AreElementsEqual(x, source, (a, b) => object.Equals(a, b));
}
public void Memoize <T>([PexAssumeNotNull] T[] source)
{
PexAssume.IsTrue(source.Length > 5);
var x = 0;
var y = 0;
var enumerable = source.Do(_ => x++).Memoize();
var firstEnumerator = enumerable.GetEnumerator();
var sourceEnumerator = source.GetEnumerator();
for (var i = 0; i < 5; i++)
{
PexAssert.IsTrue(sourceEnumerator.MoveNext());
PexAssert.IsTrue(firstEnumerator.MoveNext());
PexAssert.AreEqual(sourceEnumerator.Current, firstEnumerator.Current);
}
var secondEnumerator = enumerable.GetEnumerator();
for (var i = 0; i < source.Length - 5; i++)
{
PexAssert.IsTrue(sourceEnumerator.MoveNext());
PexAssert.IsTrue(firstEnumerator.MoveNext());
PexAssert.IsTrue(secondEnumerator.MoveNext());
PexAssert.AreEqual(sourceEnumerator.Current, firstEnumerator.Current);
PexAssert.AreEqual(sourceEnumerator.Current, secondEnumerator.Current);
}
PexAssert.IsFalse(sourceEnumerator.MoveNext());
PexAssert.IsFalse(firstEnumerator.MoveNext());
PexAssert.IsFalse(secondEnumerator.MoveNext());
}
public void RemoveSettingsPUT2([PexAssumeUnderTest] String[] name, [PexAssumeUnderTest] Object[] value)
{
PexAssume.IsTrue(name.Length == value.Length);
for (int i = 0; i < value.Length; i++)
{
PexAssume.IsTrue(value[i] is bool || value[i] is String || value[i] is int);
PexAssume.IsNotNullOrEmpty(name[i]);
PexAssume.IsNotNull(value[i]);
//PexAssume.IsTrue(name[i].Contains("t"));
}
for (int i = 0; i < name.Length - 1; i++)
{
storage.SaveSetting(name[i], value[i]);
}
for (int i = 0; i < name.Length - 1; i++)
{
if (storage.GetSetting(name[i]) != null)
{
storage.RemoveSetting(name[i]);
PexAssert.IsNull(storage.GetSetting(name[i]), name[i] + " not removed");
}
}
if (name.Length > 0)
{
PexAssert.AreEqual(null, storage.GetSetting(name[name.Length - 1]));
}
}
/// Summary
/// Time: 7 min 28 sec
/// Pattern: AAAA, State Relation
/// Failing Tests - When the list includes a null value, Remove() returns true event if the inputval does not exist in the linked list
public void RemoveWithNoMatchTest([PexAssumeUnderTest] List <string> list, string inputval)
{
PexAssume.IsFalse(list.Contains(inputval));
SinglyLinkedList <string> sll = new SinglyLinkedList <string> (list);
PexAssert.AreEqual(list.Count, sll.Count);
PexAssert.IsFalse(sll.Remove(inputval));
}
/// Summary
/// Time: 1 min 46 sec
/// Pattern: Constructor Test, State Relation
/// Combines two tests into a single test
public void ToArrayTest([PexAssumeUnderTest] int[] expected)
{
PexAssume.IsNotNull(expected);
SinglyLinkedList <int> sll = new SinglyLinkedList <int>(expected);
CollectionAssert.AreEqual(expected, sll.ToArray());
PexAssert.AreEqual(expected.Length, sll.ToArray().Length);
}
public void ClearPUT([PexAssumeUnderTest] List <int> values)
{
AvlTree <int> actual = new AvlTree <int>(values);
PexAssert.AreEqual(values.Count, actual.Count);
actual.Clear();
PexAssert.AreEqual(0, actual.Count);
}
public TagTypes TagTypesGetTest([PexAssumeUnderTest] XmpTag target)
{
TagTypes result = target.TagTypes;
PexAssert.AreEqual(result, TagTypes.XMP);
return(result);
// TODO: add assertions to method XmpTagTest.TagTypesGetTest(XmpTag)
}
public uint?FocalLengthIn35mmFilmGetTest([PexAssumeUnderTest] XmpTag target)
{
uint?result = target.FocalLengthIn35mmFilm;
PexAssert.AreEqual(result, target.GetUIntNode(XmpTag.EXIF_NS, "FocalLengthIn35mmFilm"));
return(result);
// TODO: add assertions to method XmpTagTest.FocalLengthIn35mmFilmGetTest(XmpTag)
}
public void IsHoliday03()
{
bool b;
b = this.IsHoliday(new DateTime(-4611686018427387905L & 364240249997688832L,
(DateTimeKind)(364240249997688832uL >> 62)));
PexAssert.AreEqual <bool>(true, b);
}
public void CanClearEntriesPUT([PexAssumeUnderTest] String name1, [PexAssumeUnderTest] String name2)
{
PexAssume.IsFalse(name1.Equals(name2));
categoryManager.Add(name1);
categoryManager.Add(name2);
categoryManager.Clear();
PexAssert.AreEqual(0, categoryManager.Categories.Count);
}
public void ClearPUT([PexAssumeUnderTest] int[] input)
{
Deque <int> actual = new Deque <int> (input);
actual.Clear();
PexAssert.AreEqual(0, actual.Count);
}
public void EnqueueFrontPUT([PexAssumeNotNull] Collection <int> input, int val)
{
Deque <int> actual = new Deque <int>(input);
int initCount = actual.Count;
actual.EnqueueFront(val);
PexAssert.AreEqual(initCount + 1, actual.Count);
}
public void ConstructorPUT(int value)
{
DoublyLinkedListNode <int> n = new DoublyLinkedListNode <int>(value);
PexAssert.AreEqual(value, n.Value);
PexAssert.IsNull(n.Previous);
PexAssert.IsNull(n.Next);
}
public void FibonacciPUT(int actual)
{
if (actual <= 1)
{
PexAssert.AreEqual(actual, actual.Fibonacci());
}
actual.Fibonacci();
}
public void IsHoliday02()
{
bool b;
b = this.IsHoliday(new DateTime(-4611686018427387905L & 72280358225313792L,
(DateTimeKind)(72280358225313792uL >> 62)));
PexAssert.AreEqual <bool>(false, b);
}
public void TryActionTest0125902()
{
bool b;
b = this.TryActionTest01
((AphidInterpreter)null, (string)null, (Action)null, false);
PexAssert.AreEqual <bool>(false, b);
}
public void IsHoliday04()
{
bool b;
b = this.IsHoliday(new DateTime(-4611686018427387905L & 221694300028665856L,
(DateTimeKind)(221694300028665856uL >> 62)));
PexAssert.AreEqual <bool>(true, b);
}
public double?AltitudeGetTest([PexAssumeUnderTest] XmpTag target)
{
double?result = target.Altitude;
PexAssert.AreEqual(target.Altitude, null);
return(result);
// TODO: add assertions to method XmpTagTest.AltitudeGetTest(XmpTag)
}
