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