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