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