public void RemovingItemsShouldChangeTheContentHash(string[] initialContents, int[] itemsToRemove) { PexAssume.IsNotNullOrEmpty(initialContents); PexAssume.IsNotNullOrEmpty(itemsToRemove); PexAssume.AreDistinctValues(initialContents); PexAssume.AreDistinctValues(itemsToRemove); PexAssume.TrueForAll(itemsToRemove, x => x < initialContents.Length && x > 0); (new TestScheduler()).With(sched => { var fixture = new SerializedCollection <ModelTestFixture>(initialContents.Select(x => new ModelTestFixture() { TestString = x })); var hashes = new List <Guid>(); int changeCount = 0; fixture.Changed.Subscribe(_ => { changeCount++; hashes.Add(fixture.ContentHash); }); var toRemove = itemsToRemove.Select(x => fixture[x]); foreach (var v in toRemove) { fixture.Remove(v); } sched.Start(); PexAssert.AreDistinctValues(hashes.ToArray()); PexAssert.AreEqual(itemsToRemove.Length, changeCount); }); }
public static UndirectedGraph <int, Edge <int> > CreateGraphArrayOfNodesAndEdgesAssume([PexAssumeNotNull] int[] nodes, [PexAssumeNotNull] bool[] edges) { //PexAssume.IsTrue(nodes.Length <= 7 || nodes.Length > 7); PexAssume.IsTrue(edges.Length <= 6 || nodes.Length > 6); PexAssume.IsTrue(edges.Length <= nodes.Length); PexAssume.AreDistinctValues(nodes); //PexAssume.TrueForAll(nodes, e => e != 0); UndirectedGraph <int, Edge <int> > g = new UndirectedGraph <int, Edge <int> >(false); foreach (int ele in nodes) { g.AddVertex(ele); } int source = PexChoose.IndexValue("indexed value", nodes); for (int i = 0; i < edges.Length; i++) { if (edges[i] == false) { g.AddEdge(new Edge <int>(nodes[source], nodes[i])); } } return(g); }
public void InsertionAndDeletionPUT([PexAssumeUnderTest] List <int> values, int start, int end) { PexAssume.IsFalse(start < 0 || end < 0); PexAssume.IsTrue(start < values.Count); PexAssume.IsTrue(end >= start && end < values.Count); PexAssume.AreDistinctValues <int>(values.ToArray()); AvlTree <int> avlTree = new AvlTree <int>(); foreach (int i in values) { avlTree.Add(i); } PexAssert.AreEqual(values.Count, avlTree.Count); PexObserve.ValueForViewing <int>("Root", avlTree.Root.Value); int toRemoveCount = (end - start) == 0?1:end - start; IList <int> toRemove = values.GetRange(start, toRemoveCount); foreach (int i in toRemove) { avlTree.Remove(i); } PexAssert.AreEqual(values.Count - toRemoveCount, avlTree.Count); IEnumerable enumerator = avlTree.GetInorderEnumerator(); foreach (int i in enumerator) { PexObserve.ValueForViewing <int>("tree nodes", i); } }
public static UndirectedGraph <int, Edge <int> > CreateGraphArrayOfNodesAndEdges([PexAssumeNotNull] int[] nodes, [PexAssumeNotNull] bool[] edges) { PexAssume.IsTrue(edges.Length == nodes.Length); PexAssume.AreDistinctValues(nodes); PexAssume.TrueForAll(nodes, e => e <= 10 || e > 10); PexAssume.TrueForAll(nodes, e => e != 0); UndirectedGraph <int, Edge <int> > g = new UndirectedGraph <int, Edge <int> >(false); foreach (int ele in nodes) { g.AddVertex(ele); } for (int i = 0; i < edges.Length; i++) { int source = PexChoose.IndexValue("indexed value", nodes); PexObserve.ValueForViewing("CANED_SRC", source); if (edges[source] == false) { g.AddEdge(new Edge <int>(nodes[source], nodes[i])); g.AddEdge(new Edge <int>(nodes[i], nodes[i])); } } return(g); }
// [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)); }
public void TM([PexAssumeNotNull] String[] L0) { PexAssume.AreElementsNotNull(L0); PexAssume.AreDistinctValues(L0); PexAssume.IsTrue(L0.Length >= 3); Test51.L0p = Array.ConvertAll(L0, n => new Student(n)); Test51.L0q = Array.ConvertAll(L0, n => new Student(n)); ATracer.begin1(); new T5V1.M().Main(); ATracer.begin2(); new T5V2.M().Main(); Console.WriteLine(ATracer.trace1); Console.WriteLine("--------------"); Console.WriteLine(ATracer.trace2); PexAssert.AreEqual(ATracer.trace1, ATracer.trace2); //ATrace.Begin(); //PexAssert.AreBehaviorsEqual(() => new T5V1.M().Main(), // () => new T5V2.M().Main()); //ATrace.End(); }
private TreeDictionary <TKey, TValue, DefaultComparer <TKey> > CreateDictionary <TKey, TValue>( TKey[] keys, TValue[] values) where TKey : struct { PexAssume.IsNotNull(keys); PexAssume.IsNotNull(values); PexAssume.AreEqual(keys.Length, values.Length); PexAssume.AreDistinctValues(keys); return(TreeDictionary.Empty <TKey, TValue>().AddAll(keys.Zip(values))); }
/// Summary /// Time: 4 min 06 sec /// Pattern: Manual output review /// Generalizes 4 unit tests FindParentLeftSubTreeTest, FindParentRightSubTreeTest, FindParentRightSubTreeNodeNotPresentTest, /// FindParentLeftSubTreeNodeNotPresentTest into one PUT public void FindParentLeftSubTreeTest([PexAssumeUnderTest] int[] elements, int position) { PexAssume.AreDistinctValues <int>(elements); PexAssume.IsTrue(position >= 0 && position < elements.Length); BinarySearchTree <int> bst = new BinarySearchTree <int>(elements); PexAssume.AreNotEqual(bst.Root.Value, elements[position]); PexObserve.ValueForViewing <int>("FindParentValue", bst.FindParent(elements[position]).Value); }
public void CopyConstructorPUT(List <int> values) { AvlTree <int> avlTree = new AvlTree <int>(values); PexAssume.AreDistinctValues <int>(values.ToArray()); List <int> actual = new List <int>(values.Count); foreach (int i in avlTree) { actual.Add(i); } CollectionAssert.AreEquivalent(values.ToArray(), actual.ToArray()); }
public void TraversalPUT([PexAssumeUnderTest] List <int> values) { PexAssume.AreDistinctValues <int>(values.ToArray()); AvlTree <int> avlTree = new AvlTree <int> (values); List <int> actual = new List <int>(); foreach (int value in avlTree.GetInorderEnumerator()) { actual.Add(value); } values.Sort(); CollectionAssert.AreEqual(values, actual); }
public static Dictionary <int, int> createDictionaryArrays([PexAssumeNotNull] int[] keys, int max) { PexAssume.AreDistinctValues(keys); PexAssume.IsTrue(max > 0); PexAssume.IsTrue(keys.Length <= 5 || keys.Length > 5); //PexAssume.TrueForAll(pairs, p => (p.Key > -11 && p.Key < 11) && (p.Value > -11 && p.Value < 11)); //DataStructures.Utility.Int32EqualityComparer comparer = new DataStructures.Utility.Int32EqualityComparer(); Dictionary.Dictionary <int, int> ret = new Dictionary.Dictionary <int, int>();// DataStructure has big enough capacity for Commutativity Test for (int i = 0; i < keys.Length; i++) { ret.Add(keys[i], PexChoose.ValueFromRange("value", 0, max)); } return(ret); }
public static HashSet.HashSet <int> Create([PexAssumeNotNull] int[] elems) { //PexAssume.IsTrue(elems != null && elems.Length < 11); //PexAssume.TrueForAll(0, elems.Length, _i => elems[_i] > -11 && elems[_i] < 11); PexAssume.AreDistinctValues(elems); HashSet.HashSet <int> ret = new HashSet.HashSet <int>();// DataStructure has big enough capacity for Commutativity Test for (int i = 0; i < elems.Length; i++) { //PexAssume.IsTrue(elems[i] > -101 && elems[i] < 101); // For stack, add any element. //if(!ret.Contains(elems[i])) ret.Add(elems[i]); } return(ret); }
public void TM([PexAssumeNotNull] String[] L0) { PexAssume.AreElementsNotNull(L0); PexAssume.AreDistinctValues(L0); PexAssume.IsTrue(L0.Length > 1); //String[] L1 = L0.UCopy().USort((a, b) => a.CompareTo(b)); String[] L1 = L0.OrderBy(x => x).ToArray(); //new String[L0.Length]; //L0.UCopyTo(L1); //Array.Sort(L1); //PexAssert.AreElementsEqual(L0, L1); //System.Console.WriteLine(String.Join(",", L0)); //System.Console.WriteLine("".Equals("\0")); //System.Console.WriteLine("\0".CompareTo("\0\0")); PexAssert.IsTrue(L0.SequenceEqual(L1)); }
public static Dictionary <int, int> Create([PexAssumeNotNull] int[] keys, [PexAssumeNotNull] int[] values) { PexAssume.AreDistinctValues(keys); PexAssume.IsTrue(keys.Length <= 3 || keys.Length > 3); PexAssume.IsTrue(keys.Length == values.Length); PexAssume.TrueForAll(0, keys.Length, _i => keys[_i] <= 1 || keys[_i] > 1); //PexAssume.TrueForAll(0, values.Length, _j => values[_j] <= -3 || values[_j] > -3); //DataStructures.Utility.Int32EqualityComparer comparer = new DataStructures.Utility.Int32EqualityComparer(); Dictionary.Dictionary <int, int> ret = new Dictionary.Dictionary <int, int>();// DataStructure has big enough capacity for Commutativity Test for (int i = 0; i < keys.Length; i++) { // For stack, add any element. //if (!ret.ContainsKey(keys[i])) ret.Add(keys[i], values[i]); } return(ret); }
public void RemoveMaxHeapTest([PexAssumeNotNull] int[] input) { //PexAssume.IsTrue(input.Length > 0); PexAssume.AreDistinctValues <int>(input); List <int> temp = new List <int>(input); temp.Sort(); List <int> inputWithoutMax = new List <int>(input); int max = temp.ToArray()[temp.Count - 1]; inputWithoutMax.Remove(max); Heap <int> actual = new Heap <int>(input, Strategy.Max); Heap <int> expected = new Heap <int>(inputWithoutMax, Strategy.Max); PexAssert.IsTrue(actual.Remove(max)); PexObserve.ValueForViewing <int[]>("Expected", expected.ToArray()); PexObserve.ValueForViewing <int[]>("Actual", actual.ToArray()); CollectionAssert.AreEquivalent(expected, actual); }