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);
}
}
/// 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));
}
/// Summary
/// Time: 1 min 24 sec
/// Pattern: AAAA, State Relation
public void FindParentNoItemsInBstTest([PexAssumeUnderTest] List <int> elements, int notexistelement)
{
PexAssume.IsFalse(elements.Contains(notexistelement));
BinarySearchTree <int> bst = new BinarySearchTree <int>(elements);
PexAssert.IsNull(bst.FindParent(notexistelement));
}
public void GcdPUT(int first, int second)
{
PexAssume.IsFalse(first < 0 || second < 0);
if (first == 0 || second == 0)
{
first = (first == 0) ? second : first;
}
else if (first == 1 || second == 1)
{
first = (first == 1) ? first : second;
}
else
{
while (first != second)
{
if (first > second)
{
first = first - second;
}
else
{
first = first - second;
}
}
}
PexAssert.AreEqual(first, Numbers.GreatestCommonDenominator(first, second));
}
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);
}
}
}
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());
}
/// 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));
}
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 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 CanGetTcpChannelOnSpecifiedPortPUT3([PexAssumeUnderTest] String name, int port)
{
PexAssume.IsFalse(name.Equals(""));
//PexAssume.IsTrue(port > 1000 && port < 5000);
TcpChannel chan1 = ServerUtilities.GetTcpChannel(name, port);
ChannelDataStore cds = (ChannelDataStore)chan1.ChannelData;
String uriInfo = "tcp://127.0.0.1:" + port;
PexAssert.AreEqual(uriInfo, cds.ChannelUris[0]);
}
/// Summary
/// Time: 2 min 55 sec
/// Pattern: AAAA, Round Trip
/// Generalizes three unit tests "FindNodeValidLeftChildTest, FindNodeValidRightChildTest, FindNodeNotInBstTest" into one PUT
public void FindNodeValidLeftChildTest([PexAssumeUnderTest] List <int> elements, int position, int notExistingElement)
{
PexAssume.IsTrue(position >= 0 && position < elements.Count);
PexAssume.IsFalse(elements.Contains(notExistingElement));
BinarySearchTree <int> bst = new BinarySearchTree <int>(elements);
PexAssert.IsNotNull(bst.FindNode(elements[position]));
PexAssert.AreEqual(elements[position], bst.FindNode(elements[position]).Value);
PexAssume.IsNull(bst.FindNode(notExistingElement));
}
public void AddAfterTailPUT([PexAssumeUnderTest] IList <int> values, int toAddValue)
{
PexAssume.IsTrue(values.Count > 1);
PexAssume.IsFalse(values.Contains(toAddValue));
DoublyLinkedList <int> dll = new DoublyLinkedList <int> (values);
dll.AddAfter(dll.Tail, toAddValue);
PexAssert.AreEqual(toAddValue, dll.Tail.Value);
PexAssert.AreEqual(values[values.Count - 1], dll.Tail.Previous.Value);
}
/// 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 PowerExponentLessThanZeroPUT(int baseVal, int exponent)
{
PexAssume.IsFalse(exponent > 0);
if (exponent == 0)
{
PexAssert.AreEqual(1, Numbers.Power(baseVal, exponent));
}
else
{
Numbers.Power(baseVal, exponent);
}
}
public void StripPUT(string actual)
{
Regex charPattern = new Regex(@"[a-zA-Z]");
// char[] ch = {'\u0001'};
//actual = new string(ch);
PexAssume.IsTrue(charPattern.IsMatch(actual));
PexAssume.IsFalse(actual.Contains("\0"));
PexAssume.IsFalse(actual.Contains("\\"));
string expected = Regex.Replace(actual, "[^a-zA-Z]", "");
PexAssert.AreEqual(expected, actual.Strip());
}
public void CountPUT([PexAssumeUnderTest] IList <int> values, int randomPick1)
{
PexAssume.IsFalse(values.Contains(randomPick1));
PexAssume.IsTrue(values.Count > 1);
DoublyLinkedList <int> dll = new DoublyLinkedList <int> (values);
dll.RemoveFirst();
dll.RemoveLast();
PexAssert.AreEqual(values.Count - 2, dll.Count);
dll.Add(randomPick1);
dll.AddAfter(dll.Head, values[0]);
dll.AddBefore(dll.Head.Next, values[values.Count - 1]);
PexAssert.AreEqual(values.Count + 1, dll.Count);
}
public void ReversePUT(string input)
{
if (input == null)
{
input.Reverse();
PexAssume.IsFalse(true, "Exception should have been thrown");
}
Regex charPattern = new Regex(@"^[a-zA-Z]*$");
PexAssume.IsTrue(charPattern.IsMatch(input));
string actual = input.Reverse();
string expected = "";
foreach (char c in input.ToCharArray())
{
expected = c.ToString() + expected;
}
PexAssert.AreEqual(expected, actual);
}
public void MaxValueDigitsLessThanZeroPUT(int exponentVal)
{
PexAssume.IsFalse(exponentVal > 0);
if (exponentVal < 0)
{
try
{
Numbers.MaxValue(Base.Binary, exponentVal);
}
catch (ArgumentOutOfRangeException ex)
{
PexGoal.Reached();
}
}
else
{
PexAssert.AreEqual(0, Numbers.MaxValue(Base.Binary, exponentVal));
}
}
//check for substorage setting save
public void SubstorageSettingsPUT1([PexAssumeUnderTest] String subName, [PexAssumeUnderTest] String[] name, Object[] value)
{
//constraints for NOT NULL Arrays
PexAssume.IsNotNull(value);
//constraints for equal size arrays
PexAssume.IsTrue(name.Length == value.Length);
for (int i = 0; i < value.Length; i++)
{
//constraint for the TYPE of Object to be created
PexAssume.IsTrue(value[i] is String || value[i] is int);
//constraint for each name to be NOT NULL
PexAssume.IsNotNull(name[i]);
PexAssume.IsTrue(name[i].Contains("t"));
//constraint for each value to be NOT NULL
PexAssume.IsNotNull(value[i]);
}
//Constratraint to avoid duplicate values
for (int i = 0; i < name.Length; i++)
{
for (int j = 0; j < name.Length; j++)
{
PexAssume.IsFalse(name[j].Equals(name[j]));
}
}
ISettingsStorage sub = storage.MakeChildStorage(subName);
for (int j = 0; j < value.Length; j++)
{
sub.SaveSetting(name[j], value[j]);
}
for (int j = 0; j < value.Length; j++)
{
PexAssert.AreEqual(value[j], sub.GetSetting(name[j]));
}
}
public void RemoveTreePUT([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);
AvlTree <int> avlTree = new AvlTree <int>(values);
int toRemoveCount = (end - start) == 0 ? (values.Count > 0? 1:0) : end - start;
IList <int> toRemove = values.GetRange(start, toRemoveCount);
foreach (int i in toRemove)
{
bool result = avlTree.Remove(i);
PexAssert.IsTrue(result);
}
PexAssert.AreEqual(values.Count - toRemoveCount, avlTree.Count);
IEnumerable enumerator = avlTree.GetInorderEnumerator();
foreach (int i in enumerator)
{
PexObserve.ValueForViewing <int>("tree nodes", i);
}
}
public void WordCountPUT(string actual)
{
Regex nonCharPattern = new Regex(@"[^\sa-zA-Z]$");
PexAssume.IsFalse(nonCharPattern.IsMatch(actual));
/** actual**/
int expected = actual.WordCount();
/** compute expected **/
char[] splitter = { ' ' };
string[] splits = actual.Split(splitter);
int count = 0;
for (int i = 0; i < splits.Length; i++)
{
string value = splits[i].Trim();
if (value.Length > 0)
{
count++;
}
}
PexAssert.AreEqual(count, actual.WordCount());
}
public void Test_ContainsNegative<T>([PexAssumeNotNull] T[] array, T item) where T : IComparable<T> {
var seq = OrderedSequence.FromEnumerable(array);
PexAssume.IsFalse(array.Contains(item));
Assert.DoesNotContain(item, seq);
Assert.False(seq[item].HasValue);
}
public void TestClearRoutinesPUT4([PexAssumeUnderTest] String[] name, Object[] value, [PexAssumeUnderTest] String[] key)
{
//PexAssume.IsNotNull(mainKey);
PexAssume.IsNotNull(value);
PexAssume.IsTrue(name.Length >= 1);
//PexAssume.IsTrue(key.Length < name.Length);
PexAssume.IsTrue(name.Length == value.Length);
for (int i = 0; i < name.Length; i++)
{
//if (i < name.Length)
//{
PexAssume.IsNotNullOrEmpty(name[i]);
PexAssume.IsTrue(name[i].Contains("test"));
PexAssume.IsTrue(value[i] is String || value[i] is int);
PexAssume.IsNotNull(value[i]);
// }
//if (i < key.Length)
// PexAssume.IsNotNull(key[i]);
}
for (int j = 0; j < key.Length; j++)
{
PexAssume.IsNotNull(key[j]);
PexAssume.IsFalse(key[j].Equals(""));
PexAssume.IsTrue(key[j].Contains("test"));
}
NUnitRegistry.TestMode = true;
using (RegistryKey mainKey = NUnitRegistry.CurrentUser)
{
mainKey.SetValue(name[0], value[0]);
int maxVal = key.Length > name.Length ? key.Length : name.Length;
int k = 0;
ArrayList keyList = new ArrayList();
keyList.Add(mainKey);
for (k = 0; k < maxVal; k++)
{
Random rand = new Random(k + 1);
int genNum = rand.Next();
if (keyList.Count - 1 == 0)
{
genNum = 0;
}
else
{
genNum = genNum % (keyList.Count - 1);
}
Console.WriteLine(genNum);
Console.WriteLine(keyList.ToArray()[genNum].ToString());
RegistryKey subKey = null;
if (k < key.Length)
{
subKey = ((keyList.ToArray())[genNum] as RegistryKey).CreateSubKey(key[k]);
keyList.Add(subKey);
}
else
{
subKey = (keyList.ToArray())[genNum] as RegistryKey;
}
// RegistryKey subKey = mainKey.CreateSubKey(key[k - 1]);
// RegistryKey testSubKey = subKey.CreateSubKey("test" + keyList.Count);
// testSubKey.SetValue("boo", "booo");
if (k < name.Length)
{
subKey.SetValue(name[k], value[k]);
}
}
NUnitRegistry.ClearTestKeys();
PexAssert.IsTrue(mainKey.ValueCount == 0);
PexAssert.IsTrue(mainKey.SubKeyCount == 0);
}
}
