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 InsertionRotateRightLeftPUT22() { List <int> list; List <int> list1; int[] ints = new int[0]; list = new List <int>((IEnumerable <int>)ints); int[] ints1 = new int[7]; ints1[0] = -715828223; ints1[1] = 1700090882; ints1[2] = -715828223; ints1[3] = 1427444738; ints1[4] = 1159009280; ints1[5] = -2147483647; ints1[6] = int.MinValue; list1 = new List <int>((IEnumerable <int>)ints1); this.InsertionRotateRightLeftPUT(list1, list, list); PexAssert.IsNotNull((object)list1); PexAssert.AreEqual <int>(7, list1.Capacity); PexAssert.AreEqual <int>(7, list1.Count); PexAssert.IsNotNull((object)list); PexAssert.AreEqual <int>(0, list.Capacity); PexAssert.AreEqual <int>(0, list.Count); PexAssert.IsNotNull((object)list); PexAssert.IsTrue(object.ReferenceEquals((object)list, (object)list)); }
public string TrimStartWithMax(string input, string startsWith, StringComparison comparisonType, int max) { PexAssume.IsNotNull(input); PexAssume.IsNotNull(startsWith); int count; string result = CommonStringExtensions.TrimStart(input, startsWith, comparisonType, max, out count); PexAssert.IsNotNull(result); PexAssert.IsTrue(result.Length <= input.Length); bool isStartsWithNotEmpty = startsWith.Length > 0; if (isStartsWithNotEmpty) { int originalStartsWithCount = CommonStringExtensions.CountSubstringStart(input, startsWith, comparisonType); int resultStartsWithCount = CommonStringExtensions.CountSubstringStart(result, startsWith, comparisonType); PexAssert.IsTrue(resultStartsWithCount == 0 || resultStartsWithCount == originalStartsWithCount - max); PexAssert.IsTrue(originalStartsWithCount - resultStartsWithCount == count); } return(result); }
public void InsertionRotateRightLeftPUT19() { List <int> list; List <int> list1; int[] ints = new int[0]; list = new List <int>((IEnumerable <int>)ints); int[] ints1 = new int[7]; ints1[0] = -2088763394; ints1[1] = int.MinValue; ints1[2] = 58720253; ints1[3] = 54525951; ints1[4] = 54525951; ints1[5] = 54525951; ints1[6] = 54525951; list1 = new List <int>((IEnumerable <int>)ints1); this.InsertionRotateRightLeftPUT(list1, list, list); PexAssert.IsNotNull((object)list1); PexAssert.AreEqual <int>(7, list1.Capacity); PexAssert.AreEqual <int>(7, list1.Count); PexAssert.IsNotNull((object)list); PexAssert.AreEqual <int>(0, list.Capacity); PexAssert.AreEqual <int>(0, list.Count); PexAssert.IsNotNull((object)list); PexAssert.IsTrue(object.ReferenceEquals((object)list, (object)list)); }
public void InsertionRotateRightLeftPUT21() { List <int> list; List <int> list1; int[] ints = new int[0]; list = new List <int>((IEnumerable <int>)ints); int[] ints1 = new int[6]; ints1[0] = -87381; ints1[1] = 2147396270; ints1[2] = -87381; ints1[3] = 2147396266; ints1[4] = 2147396258; ints1[5] = 2147396256; list1 = new List <int>((IEnumerable <int>)ints1); this.InsertionRotateRightLeftPUT(list1, list, list); PexAssert.IsNotNull((object)list1); PexAssert.AreEqual <int>(6, list1.Capacity); PexAssert.AreEqual <int>(6, list1.Count); PexAssert.IsNotNull((object)list); PexAssert.AreEqual <int>(0, list.Capacity); PexAssert.AreEqual <int>(0, list.Count); PexAssert.IsNotNull((object)list); PexAssert.IsTrue(object.ReferenceEquals((object)list, (object)list)); }
public void AddFirstTest08() { SinglyLinkedList <int> singlyLinkedList; int[] ints = new int[0]; singlyLinkedList = SinglyLinkedListFactory.Create((SinglyLinkedListNode <int>)null, ints); int[] ints1 = new int[3]; ints1[0] = 1; this.AddFirstTest(singlyLinkedList, ints1); PexAssert.IsNotNull((object)singlyLinkedList); PexAssert.IsNotNull(singlyLinkedList.Head); PexAssert.AreEqual <int>(0, singlyLinkedList.Head.Value); PexAssert.IsNotNull(singlyLinkedList.Head.Next); PexAssert.AreEqual <int>(0, singlyLinkedList.Head.Next.Value); PexAssert.IsNotNull(singlyLinkedList.Head.Next.Next); PexAssert.AreEqual <int>(1, singlyLinkedList.Head.Next.Next.Value); PexAssert.IsNull(singlyLinkedList.Head.Next.Next.Next); PexAssert.IsNotNull(singlyLinkedList.Tail); PexAssert.IsTrue(object.ReferenceEquals (singlyLinkedList.Tail, singlyLinkedList.Tail.Next.Next)); PexAssert.AreEqual <bool> (false, ((CollectionBase <int>)singlyLinkedList).IsSynchronized); PexAssert.AreEqual <int>(3, ((CollectionBase <int>)singlyLinkedList).Count); }
public void SubGroupSettingsPUT3([PexAssumeUnderTest] SettingsGroup testGroup1, [PexAssumeUnderTest] String settingName, [PexAssumeUnderTest] Object settingValue) { PexAssume.IsTrue(settingName != null); PexAssume.IsTrue(settingValue != null); DelegateHandler dhObj1 = new DelegateHandler(testGroup1); SettingsGroup subGroup = new SettingsGroup(testGroup1.Storage); PexAssert.IsNotNull(subGroup); PexAssert.IsNotNull(subGroup.Storage); //Without delegate subGroup.SaveSetting(settingName, settingValue); PexAssert.AreEqual(settingValue, subGroup.GetSetting(settingName)); subGroup.RemoveSetting(settingName); PexAssert.IsNull(subGroup.GetSetting(settingName)); //With delegate DelegateHandler dhObj2 = new DelegateHandler(subGroup); subGroup.SaveSetting(settingName, settingValue); PexAssert.AreEqual(settingValue, subGroup.GetSetting(settingName)); subGroup.RemoveSetting(settingName); PexAssert.IsNull(subGroup.GetSetting(settingName)); }
public void GetEnumeratorPUT(int[] values) { DoublyLinkedList <int> dll = new DoublyLinkedList <int>(values); PexAssert.IsNotNull(dll.GetEnumerator()); PexObserve.ValueForViewing <DoublyLinkedList <int> >("Enumeration", dll); }
public void InsertionMassivePUT30() { List <int> list; int[] ints = new int[24]; ints[0] = -62914595; ints[1] = int.MinValue; ints[2] = -12548065; ints[3] = -12548065; ints[4] = -12548065; ints[5] = -12548065; ints[6] = 520355851; ints[7] = -10477506; ints[8] = -8388567; ints[9] = -46137345; ints[10] = -12582914; ints[11] = -12582913; ints[12] = -12582913; ints[13] = -12582913; ints[14] = -12582913; ints[15] = -12582913; ints[16] = -12582913; ints[17] = -12582914; ints[18] = 1602224136; ints[19] = 2130706472; ints[20] = 1593835528; ints[21] = 1056964616; ints[22] = 520093698; ints[23] = 1; list = new List <int>((IEnumerable <int>)ints); this.InsertionMassivePUT(list); PexAssert.IsNotNull((object)list); PexAssert.AreEqual <int>(24, list.Capacity); PexAssert.AreEqual <int>(24, list.Count); }
public void BadSettingPUT128() { using (PexDisposableContext disposables = PexDisposableContext.Create()) { MemorySettingsStorage memorySettingsStorage; SettingsGroup settingsGroup; string[] ss = new string[4]; object[] os = new object[4]; ss[0] = "\u5573\u8549\ue725"; ss[1] = "\u5573\u8549\ue725"; ss[2] = "\u5573\u8549\ue725"; ss[3] = "\u5573\u8549\ue725"; os[0] = "\u5573\u8549\ue725"; os[1] = "\u5573\u8549\ue725"; os[2] = "\u5573\u8549\ue725"; os[3] = "\u5573\u8549\ue725FFFFF"; memorySettingsStorage = MemorySettingsStorageFactory.Create(ss, os); disposables.Add((IDisposable)memorySettingsStorage); settingsGroup = new SettingsGroup((ISettingsStorage)memorySettingsStorage); disposables.Add((IDisposable)settingsGroup); this.BadSettingPUT1(settingsGroup, "\u5573\u8549\ue725", "UFn\u0080?@\0", 0); disposables.Dispose(); PexAssert.IsNotNull((object)settingsGroup); PexAssert.IsNull(settingsGroup.Storage); } }
public void ToReverseArrayTest10() { SinglyLinkedList <int> singlyLinkedList; int[] ints = new int[4]; singlyLinkedList = SinglyLinkedListFactory.Create((SinglyLinkedListNode <int>)null, ints); this.ToReverseArrayTest(singlyLinkedList); PexAssert.IsNotNull((object)singlyLinkedList); PexAssert.IsNotNull(singlyLinkedList.Head); PexAssert.AreEqual <int>(0, singlyLinkedList.Head.Value); PexAssert.IsNotNull(singlyLinkedList.Head.Next); PexAssert.AreEqual <int>(0, singlyLinkedList.Head.Next.Value); PexAssert.IsNotNull(singlyLinkedList.Head.Next.Next); PexAssert.AreEqual <int>(0, singlyLinkedList.Head.Next.Next.Value); PexAssert.IsNotNull(singlyLinkedList.Head.Next.Next.Next); PexAssert.AreEqual <int>(0, singlyLinkedList.Head.Next.Next.Next.Value); PexAssert.IsNull(singlyLinkedList.Head.Next.Next.Next.Next); PexAssert.IsNotNull(singlyLinkedList.Tail); PexAssert.IsTrue(object.ReferenceEquals (singlyLinkedList.Tail, singlyLinkedList.Tail.Next.Next.Next)); PexAssert.AreEqual <bool> (false, ((CollectionBase <int>)singlyLinkedList).IsSynchronized); PexAssert.AreEqual <int>(4, ((CollectionBase <int>)singlyLinkedList).Count); }
public void BadSettingPUT125() { using (PexDisposableContext disposables = PexDisposableContext.Create()) { MemorySettingsStorage memorySettingsStorage; SettingsGroup settingsGroup; string[] ss = new string[4]; string[] ss1 = new string[4]; ss[0] = "l!%\u0800\0@\0"; ss[1] = "l!%\u0800\0@\0"; ss[2] = "l!%\u0800\0@\0"; ss[3] = "l!%\u0800\0@\0"; ss1[0] = "l!%\u0800\0@\0"; ss1[1] = "l!%\u0800\0@\0"; ss1[2] = "l!%\u0800\0@\0"; ss1[3] = "l!%\u0800\0@\0"; memorySettingsStorage = MemorySettingsStorageFactory.Create(ss, (object[])ss1); disposables.Add((IDisposable)memorySettingsStorage); settingsGroup = new SettingsGroup((ISettingsStorage)memorySettingsStorage); disposables.Add((IDisposable)settingsGroup); this.BadSettingPUT1(settingsGroup, "l!%\u0800\0@\0", "l!%\u0800\0@\0", 0); disposables.Dispose(); PexAssert.IsNotNull((object)settingsGroup); PexAssert.IsNull(settingsGroup.Storage); } }
public void ContainsTest22() { List <int> list; int[] ints = new int[15]; ints[0] = -601677791; ints[1] = -601677791; ints[2] = -601677791; ints[3] = -601677791; ints[4] = -601677791; ints[5] = 341532705; ints[6] = 140189729; ints[7] = 270369; ints[8] = 335708193; ints[9] = 327713; ints[10] = 294945; ints[11] = 827425; ints[12] = 1351713; ints[13] = 68427809; ints[14] = 67543073; list = new List <int>((IEnumerable <int>)ints); this.ContainsTest(list, 339419168); PexAssert.IsNotNull((object)list); PexAssert.AreEqual <int>(15, list.Capacity); PexAssert.AreEqual <int>(15, list.Count); }
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 Stack <T> ConstructorTest <T>() { Stack <T> target = new Stack <T>(); PexAssert.IsNotNull(target); return(target); }
public void SubGroupSettingsPUT115() { using (PexDisposableContext disposables = PexDisposableContext.Create()) { MemorySettingsStorage memorySettingsStorage; SettingsGroup settingsGroup; string[] ss = new string[2]; object[] os = new object[2]; ss[0] = ""; ss[1] = ""; os[0] = ""; object boxb = (object)(default(bool)); os[1] = boxb; memorySettingsStorage = MemorySettingsStorageFactory.Create(ss, os); disposables.Add((IDisposable)memorySettingsStorage); settingsGroup = new SettingsGroup((ISettingsStorage)memorySettingsStorage); disposables.Add((IDisposable)settingsGroup); object boxb1 = (object)(default(bool)); PexSafeHelpers.AssignBoxedValue <bool>(boxb1, true); this.SubGroupSettingsPUT1(settingsGroup, "", boxb1); disposables.Dispose(); PexAssert.IsNotNull((object)settingsGroup); PexAssert.IsNull(settingsGroup.Storage); } }
public Stack <T> ConstructorTest01 <T>(int capacity) { Stack <T> target = new Stack <T>(capacity); PexAssert.IsNotNull(target); return(target); }
public void AddItemsPUT1(int numItems) { PexAssume.IsTrue(numItems >= MIN && numItems <= MAX); PexAssert.IsNotNull(recentFiles.Entries); PexAssert.AreEqual(0, recentFiles.Count); PexAssert.AreEqual(0, recentFiles.Entries.Count); for (int num = numItems; num > 0; --num) { recentFiles.SetMostRecent(num.ToString()); } int numItemsChanged = 0; if (numItems >= MIN && numItems <= recentFiles.MaxFiles) { } else { numItemsChanged = recentFiles.MaxFiles; } //Asserting the behavior for (int num = 1; num <= numItemsChanged; num++) { PexAssert.AreEqual(recentFiles.Entries[num - 1].Path, num + ""); } //CheckAddItems(1); }
/// Summary /// Time: 1 min 03 sec /// Pattern: AAA, State Relation /// Combines two unit tests: GetEnumeratorTest and GetReverseEnumeratorTest into one PUT public void GetEnumeratorTest([PexAssumeUnderTest] SinglyLinkedList <int> sll) { IEnumerable enumerSll = sll; PexAssert.IsNotNull(enumerSll.GetEnumerator()); PexAssert.IsNotNull(sll.GetReverseEnumerator()); }
public string Replace(string input, string oldValue, string newValue, int startIndex, int count, StringComparison comparisonType) { string result = input.Replace(oldValue, newValue, startIndex, count, comparisonType); PexAssert.IsNotNull(result); return(result); }
public void MakeSubStorages() { ISettingsStorage sub1 = storage.MakeChildStorage("Sub1"); ISettingsStorage sub2 = storage.MakeChildStorage("Sub2"); PexAssert.IsNotNull(sub1, "Sub1 is null"); PexAssert.IsNotNull(sub2, "Sub2 is null"); }
public IEnumerable <string> AllBetween(string input, string enclosure) { IEnumerable <string> result = CommonStringExtensions.AllBetween(input, enclosure); PexAssert.IsNotNull(result); return(result); }
public IEnumerable <string> AllBetween(string input, char firstEnclosureCharacter, char secondEnclosureCharacter) { IEnumerable <string> result = CommonStringExtensions.AllBetween(input, firstEnclosureCharacter, secondEnclosureCharacter); PexAssert.IsNotNull(result); return(result); }
public void PeekBackEmptyDequePUT02() { Collection <int> collection; int[] ints = new int[0]; collection = CollectionFactory.Create(ints); this.PeekBackEmptyDequePUT(collection); PexAssert.IsNotNull((object)collection); }
/// Summary /// Time: 8 min 2 sec /// Pattern: Commutative diagram, AAAA /// Generalizes two tests "ToArrayTest and GetEnumeratorTest" into one PUT public void ToArrayTest([PexAssumeUnderTest] HashSet <int> inputElem) { OrderedSet <int> set = new OrderedSet <int>(inputElem); List <int> listElem = new List <int>(inputElem); listElem.Sort(); PexAssert.IsNotNull(set.GetEnumerator()); CollectionAssert.AreEqual(listElem, set); }
public string RightOfLast(string input, string value, StringComparison comparisonType) { string result = CommonStringExtensions.RightOfLast(input, value, comparisonType); PexAssert.IsNotNull(result); PexAssert.IsTrue(result.Length <= input.Length); return(result); }
public string RightOfLast(string input, char character) { string result = CommonStringExtensions.RightOfLast(input, character); PexAssert.IsNotNull(result); PexAssert.IsTrue(result.Length <= input.Length); return(result); }
public string Left(string input, int length) { string result = CommonStringExtensions.Left(input, length); PexAssert.IsNotNull(result); PexAssert.AreEqual(result.Length, length); return(result); }
public string LeftOfLast(string input, string value) { string result = CommonStringExtensions.LeftOfLast(input, value); PexAssert.IsNotNull(result); PexAssert.IsTrue(result.Length <= input.Length); return(result); }
public void IsSynchronizedTest18() { Collection <int> collection; int[] ints = new int[5]; collection = CollectionFactory.Create(ints); this.IsSynchronizedTest(collection); PexAssert.IsNotNull((object)collection); }