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)); }