public void Zip <T, U>(
[PexAssumeNotNull] T[] first,
[PexAssumeNotNull] U[] second)
{
var enumerable = first.Zip(second, (a, b) => Tuple.Create(a, b));
var e1 = first.GetEnumerator();
var e2 = second.GetEnumerator();
using (var ez = enumerable.GetEnumerator())
{
var ezCounter = 0;
while (e1.MoveNext() && e2.MoveNext())
{
ezCounter++;
PexAssert.IsTrue(ez.MoveNext());
var res = ez.Current;
PexAssume.AreNotEqual(e1.Current, e2.Current);
PexAssert.AreEqual(res.First, e1.Current);
PexAssert.AreEqual(res.Second, e2.Current);
}
PexAssert.IsFalse(ez.MoveNext());
PexAssert.AreEqual(ezCounter,
Math.Min(first.Length, second.Length));
}
}
public void MaterializeThrow <T>([PexAssumeNotNull] IEnumerable <T> source)
{
var ex = new Exception();
var joined = source.Concat(EnumerableEx.Throw <T>(ex));
var enumerable = joined.Materialize();
var enumerator = enumerable.GetEnumerator();
var sourceEnumerator = source.GetEnumerator();
while (sourceEnumerator.MoveNext())
{
PexAssert.IsTrue(enumerator.MoveNext());
var onNext = enumerator.Current as Notification <T> .OnNext;
PexAssert.IsNotNull(onNext);
PexAssert.AreEqual(sourceEnumerator.Current, onNext.Value);
}
PexAssert.IsTrue(enumerator.MoveNext());
var onError = enumerator.Current as Notification <T> .OnError;
PexAssert.IsNotNull(onError);
PexAssert.AreEqual(ex, onError.Exception);
PexAssert.IsFalse(enumerator.MoveNext());
}
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());
}
}
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));
}
private void Amb([PexAssumeNotNull] IEnumerable <int> firstSource, [PexAssumeNotNull] IEnumerable <int> secondSource, int firstDelay, int secondDelay)
{
PexAssume.InRange(firstDelay, 0, 10);
PexAssume.InRange(secondDelay, 0, 10);
PexAssume.IsTrue(firstDelay != secondDelay);
var first = AmbHelper(firstSource, firstDelay);
var second = AmbHelper(secondSource, secondDelay);
var enumerable = first.Amb(second);
var enumerator = enumerable.GetEnumerator();
var selectedSource = firstDelay < secondDelay ? firstSource : secondSource;
var sourceEnumerator = selectedSource.GetEnumerator();
var firstSourceMove = sourceEnumerator.MoveNext();
var firstAmbMove = enumerator.MoveNext();
PexAssert.AreEqual(firstSourceMove, firstAmbMove);
if (firstAmbMove)
{
var firstThread = enumerator.Current.Second;
PexAssert.AreEqual(sourceEnumerator.Current, enumerator.Current.First);
while (sourceEnumerator.MoveNext())
{
PexAssert.IsTrue(enumerator.MoveNext());
PexAssert.AreEqual(sourceEnumerator.Current, enumerator.Current.First);
PexAssert.AreEqual(firstThread, enumerator.Current.Second);
}
PexAssert.IsFalse(enumerator.MoveNext());
}
}
// [PexExpectedGoals("g1;g2;g3;g4")]
public void RemoveTailPUT([PexAssumeUnderTest] IList <int> values, int randomPick1)
{
PexAssume.AreDistinctValues <int>(values as int[]);
PexAssume.IsTrue(values.Contains(randomPick1));
DoublyLinkedList <int> dll = new DoublyLinkedList <int> (values);
bool tail = dll.Tail.Value == randomPick1 ? true:false;
bool head = dll.Head.Value == randomPick1 ? true : false;
PexObserve.ValueForViewing <bool>("isTail", tail);
PexObserve.ValueForViewing <bool>("isHead", head);
dll.Remove(randomPick1);
PexAssert.AreEqual(values.Count - 1, dll.Count);
if (values.Count == 1)
{
PexAssert.IsTrue(dll.IsEmpty());
//PexGoal.Reached("g1");
return;
}
if (values.Count == 2)
{
PexAssert.AreEqual(dll.Head, dll.Tail);
//PexGoal.Reached("g2");
}
if (tail)
{
PexAssert.AreEqual(values[values.Count - 2], dll.Tail.Value);
//PexGoal.Reached("g3");
}
if (head)
{
PexAssert.AreEqual(values[1], dll.Head.Value);
// PexGoal.Reached("g4");
}
PexAssert.IsFalse(dll.Contains(randomPick1));
}
/// Summary
/// Time: 1 min 27 sec
/// Pattern: AAA, Constructor Test
public void ReadOnlyTest([PexAssumeUnderTest] int[] elements)
{
BinarySearchTree <int> bst = new BinarySearchTree <int>(elements);
ICollection <int> actual = bst;
PexAssert.IsFalse(actual.IsReadOnly);
}
public void OnErrorResumeNext <T>([PexAssumeNotNull] IEnumerable <T> begin, [PexAssumeNotNull] IEnumerable <T> rest, bool ShouldThrow)
{
var ex = new Exception();
var start = begin;
if (ShouldThrow)
{
start = start.Concat(EnumerableEx.Throw <T>(ex));
}
var enumerable = start.OnErrorResumeNext(rest);
var enumerator = enumerable.GetEnumerator();
var beginEnumerator = begin.GetEnumerator();
while (beginEnumerator.MoveNext())
{
PexAssert.IsTrue(enumerator.MoveNext());
PexAssert.AreEqual(beginEnumerator.Current, enumerator.Current);
}
var restEnumerator = rest.GetEnumerator();
while (restEnumerator.MoveNext())
{
PexAssert.IsTrue(enumerator.MoveNext());
PexAssert.AreEqual(restEnumerator.Current, enumerator.Current);
}
PexAssert.IsFalse(enumerator.MoveNext());
}
public void Scan <T>([PexAssumeNotNull] IEnumerable <T> source)
{
var enumerable =
source.Scan(
Tuple.Create(0,
default
(
T
)), (x, e) => Tuple.Create(x.First + 1, e));
var enumerator = enumerable.GetEnumerator();
var sourceEnumerator = source.GetEnumerator();
var count = 0;
PexAssert.IsTrue(enumerator.MoveNext());
PexAssert.AreEqual(enumerator.Current.First, count);
PexAssert.AreEqual(enumerator.Current.Second, default(T));
while (sourceEnumerator.MoveNext())
{
count++;
PexAssert.IsTrue(enumerator.MoveNext());
PexAssert.AreEqual(count, enumerator.Current.First);
PexAssert.AreEqual(sourceEnumerator.Current, enumerator.Current.Second);
}
PexAssert.IsFalse(enumerator.MoveNext());
}
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 ReverseWordsPUT(string input)
{
if (input == null)
{
input.Reverse();
PexAssert.IsFalse(true, "Null exception was supposed to be thrown");
}
Regex nonCharPattern = new Regex(@"[^a-zA-Z\s]");
PexAssume.IsFalse(nonCharPattern.IsMatch(input));
input = input.TrimEnd();
char[] splitter = { ' ' };
String[] splits = input.Split(splitter);
string reverse = "";
for (int i = 0; i < splits.Length; i++)
{
string splitStr = splits[i];
if (!splitStr.Equals(" ") || (reverse.Length > 0 && reverse.TrimEnd().Equals(reverse)))
{
if (reverse.Length > 0)
{
reverse = splitStr + " " + reverse.TrimStart();
}
else
{
reverse = splitStr;
}
}
}
PexAssert.AreEqual(reverse.TrimEnd(), input.ReverseWords());
}
public void ChangingASerializableItemShouldChangeTheContentHash(string[] items, int toChange, string newValue)
{
PexAssume.IsNotNullOrEmpty(items);
PexAssume.TrueForAll(items, x => x != null);
PexAssume.AreDistinctReferences(items);
PexAssume.IsTrue(toChange >= 0 && toChange < items.Length);
(new TestScheduler()).With(sched => {
var fixture = new SerializedCollection <ModelTestFixture>(
items.Select(x => new ModelTestFixture()
{
TestString = x
}));
bool shouldDie = true;
var hashBefore = fixture.ContentHash;
PexAssume.AreNotEqual(newValue, fixture[toChange].TestString);
fixture.Changed.Subscribe(_ => shouldDie = false);
Observable.Return(newValue, sched).Subscribe(x => fixture[toChange].TestString = x);
sched.Start();
PexAssert.AreNotEqual(hashBefore, fixture.ContentHash);
PexAssert.IsFalse(shouldDie);
});
}
/// Summary
/// Time: 1 min 03 sec
/// Pattern: Constructor Test
/// Combines two unit tests into PUT
public void RemoveFirstEmptyListTest(int value)
{
SinglyLinkedList <int> sll = new SinglyLinkedList <int>();
PexAssert.IsFalse(sll.RemoveFirst());
PexAssert.IsFalse(sll.Remove(value));
}
/// Summary
/// Time: 1 min 24 sec
/// Pattern: AAAA, State Relation
public void RemoveNodeNotFoundTest([PexAssumeUnderTest] List <int> elements, int notexistelement)
{
PexAssume.IsFalse(elements.Contains(notexistelement));
BinarySearchTree <int> bst = new BinarySearchTree <int>(elements);
PexAssert.IsFalse(bst.Remove(notexistelement));
}
public void RemoveTreeEmptyPUT()
{
AvlTree <int> avlTree = new AvlTree <int>();
bool result = avlTree.Remove(3);
PexAssert.IsFalse(result);
}
/// Summary
/// Time: 3 min 52 sec
/// Pattern: AAAA, State relation
public void AddRemoveVertex([PexAssumeUnderTest] AdjacencyGraph g)
{
IVertex v = g.AddVertex();
g.RemoveVertex(v);
PexAssert.IsFalse(g.ContainsVertex(v));
}
public void Retry <T>([PexAssumeNotNull] T[] source, uint throwTimes, [PexAssumeNotNull] IEnumerable <T> rest)
{
PexAssume.IsTrue(source.Length > 0);
PexAssume.IsTrue(throwTimes < uint.MaxValue);
var counter = 0;
var begin = source.Concat(ThrowHelper <T>(() =>
{
counter++;
return(counter <= throwTimes);
}));
var total = begin.Concat(rest).Retry();
var totalEnumerator = total.GetEnumerator();
for (var i = 0; i < throwTimes + 1; i++)
{
var sourceEnumerator = source.GetEnumerator();
while (sourceEnumerator.MoveNext())
{
PexAssert.IsTrue(totalEnumerator.MoveNext());
PexAssert.AreEqual(sourceEnumerator.Current, totalEnumerator.Current);
}
}
var restEnumerator = rest.GetEnumerator();
while (restEnumerator.MoveNext())
{
PexAssert.IsTrue(totalEnumerator.MoveNext());
PexAssert.AreEqual(restEnumerator.Current, totalEnumerator.Current);
}
PexAssert.IsFalse(totalEnumerator.MoveNext());
}
public void CanLocateAgentExecutablePUT1([PexAssumeUnderTest] String path)
{
//string path = TestAgency.TestAgentExePath;
//PexAssert.AreEqual( System.IO.File.Exists(path), "Cannot find " + path );
//Had to change it to run the test case
PexAssert.IsFalse(System.IO.File.Exists(path));
}
public void AddAfterPUT([PexAssumeUnderTest] IList <int> values, int toAddValue)
{
PexAssume.IsFalse(values.Contains(toAddValue));
DoublyLinkedList <int> dll = new DoublyLinkedList <int>(values);
if (values.Count == 0)
{
dll.AddAfter(dll.Head, toAddValue);
PexAssert.IsFalse(true, "InvalidOperationException was expected");
}
dll.AddAfter(dll.Head.Next, toAddValue);
if (values.Count == 1)
{
PexAssert.IsFalse(true, "ArgumentNullException was expected");
}
PexAssert.AreEqual(toAddValue, dll.Head.Next.Next.Value);
PexAssert.AreEqual(values[1], dll.Head.Next.Next.Previous.Value);
if (values.Count > 2)
{
PexAssert.AreEqual(values[2], dll.Head.Next.Next.Next.Value);
if (values.Count == 3)
{
PexAssert.AreEqual(toAddValue, dll.Tail.Previous.Value);
}
}
}
/// Summary
/// Time: 1 min 27 sec
/// Pattern: AAA,Constructor Test
public void IsSynchronizedTest([PexAssumeUnderTest] Collection <int> elements)
{
BinarySearchTree <int> bst = new BinarySearchTree <int>(elements);
ICollection actual = bst;
PexAssert.IsFalse(actual.IsSynchronized);
}
/// Summary
/// Time: 16 min 1 sec
/// Pattern: Constructor Test, State Relation, AAAA
/// Failing Test: Exposed a NullReferenceException inside the code of BinarySearchTree
/// An integer value of zero is considered as a null value. However zero is a valid value
/// Interesting defect that can be mentioned in the paper also and gets exposed based on
/// how the code path is exposed
public void RemoveTest([PexAssumeUnderTest] int[] elements, int position)
{
PexAssume.IsTrue(position >= 0 && position < elements.Length);
OrderedSet <int> actual = new OrderedSet <int>(elements);
PexAssert.IsTrue(actual.Remove(elements[position]));
PexAssert.IsFalse(actual.Remove(elements[position]));
}
/// 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 59 sec
/// Pattern: AAAA, AllowedException
public void AddRemoveVertexNotFound([PexAssumeUnderTest] AdjacencyGraph g)
{
IVertex v = RandomGraph.Vertex(g, new Random());
g.RemoveVertex(v);
PexAssert.IsFalse(g.ContainsVertex(v));
g.RemoveVertex(v);
PexAssert.IsTrue(false, "ArgumentNullException was expected");
}
public void ContainsPUT([PexAssumeUnderTest] IList <int> values, int randomPick1, int randomPick2)
{
PexAssume.IsTrue(values.Contains(randomPick1));
PexAssume.IsFalse(values.Contains(randomPick2));
DoublyLinkedList <int> dll = new DoublyLinkedList <int> (values);
PexAssert.IsTrue(dll.Contains(randomPick1));
PexAssert.IsFalse(dll.Contains(randomPick2));
}
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);
}
/// Summary
/// Time: 1 min 21 sec
/// Pattern: AAAA, State Relation
public void RemoveEdge([PexAssumeUnderTest] AdjacencyGraph g)
{
IVertex v = g.AddVertex();
IVertex u = g.AddVertex();
IEdge e = g.AddEdge(u, v);
g.RemoveEdge(e);
PexAssert.IsFalse(g.ContainsEdge(e));
}
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);
}
/// Summary
/// Time: 4 min 12 sec
/// Pattern: AAAA, State Relation
/// Generalizes two tests "ContainsTest, ContainsItemNotPresentTest" into one PUT
public void ContainsTest([PexAssumeUnderTest] List <int> elements, int newElement)
{
PexAssume.IsFalse(elements.Contains(newElement));
BinarySearchTree <int> bst = new BinarySearchTree <int>(elements);
foreach (int elem in elements)
{
PexAssert.IsTrue(bst.Contains(elem));
}
PexAssert.IsFalse(bst.Contains(newElement));
}
public void IsAssemblyFileTypePUT1([PexAssumeUnderTest] String inpPath)
{
//PexAssume.IsFalse(inpPath.Contains("\0"));
if (inpPath.EndsWith(".dll") || inpPath.EndsWith(".exe"))
{
PexAssert.IsTrue(PathUtils.IsAssemblyFileType(inpPath));
}
else
{
PexAssert.IsFalse(PathUtils.IsAssemblyFileType(inpPath));
}
}
/// Summary
/// Time: 1 min 12 sec
/// Pattern: AAAA, State Relation
/// Generalized two unit tests "RemoveRootNoSubtreesTest and RemoveTreeHasNoItemsTest" into one PUT
public void RemoveRootNoSubtreesTest(int element1, int element2)
{
PexAssume.AreNotEqual(element1, element2);
BinarySearchTree <int> bst = new BinarySearchTree <int> {
element1
};
PexAssert.IsTrue(bst.Remove(element1));
PexAssert.IsNull(bst.Root);
PexAssert.AreEqual(0, bst.Count);
PexAssert.IsFalse(bst.Remove(element2));
}
