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());
}
}
/// Summary
/// Time: 8 min 1 sec
/// Pattern: State Relation, AAAA
public void RemoveFirstOneItemInListTest([PexAssumeUnderTest] SinglyLinkedList <int> sll)
{
PexAssume.IsTrue(sll.Count > 0);
int prevCount = sll.Count;
int nextFirst = 0;
if (sll.Count > 1)
{
nextFirst = sll.Head.Next.Value;
}
PexAssert.IsTrue(sll.RemoveFirst());
PexAssert.AreEqual(prevCount - 1, sll.Count);
if (prevCount == 1)
{
PexAssert.IsNull(sll.Head);
PexAssert.IsNull(sll.Tail);
}
else
{
PexAssert.IsTrue(nextFirst == sll.Head.Value);
}
}
public void AddAfterMiddleNodeTest04()
{
SinglyLinkedList <int> singlyLinkedList;
int[] ints = new int[3];
singlyLinkedList =
SinglyLinkedListFactory.Create((SinglyLinkedListNode <int>)null, ints);
this.AddAfterMiddleNodeTest(singlyLinkedList, 0);
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);
}
//check for saved substorage settings removed
public void SubstorageSettingsPUT2([PexAssumeUnderTest] String subName, [PexAssumeUnderTest] String[] name, [PexAssumeUnderTest] Object[] value)
{
PexAssume.IsTrue(name.Length == value.Length);
for (int i = 0; i < value.Length; i++)
{
PexAssume.IsTrue(value[i] is String || value[i] is int);
PexAssume.IsNotNullOrEmpty(name[i]);
PexAssume.IsNotNull(value[i]);
PexAssume.IsTrue(name[i].Contains("t"));
}
for (int i = 0; i < name.Length; i++)
{
PexAssume.IsNotNullOrEmpty(name[i]);
}
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++)
{
String curr = name[j];
sub.RemoveSetting(curr);
PexAssert.IsNull(sub.GetSetting(curr), curr + " not removed");
}
}
/// Summary
/// Time: 18 min 23 sec
/// Pattern: AAAA, Commutative diagram
/// A classic example for commutative diagram, as the operation is made in parallel using lists
/// Notes: A hashset is taken as input as we need unique elements for insertion into BST
/// Failing tests : Exposed a serious bug inside binary search tree implementation that throws NullPointerException
public void RemoveNodeWithBothSubtreesTest([PexAssumeUnderTest] HashSet <int> setelem, int position)
{
List <int> elements = new List <int>(setelem);
PexAssume.IsTrue(position >= 0 && position < elements.Count);
PexAssume.IsTrue(elements.Count > 0);
BinarySearchTree <int> bst = new BinarySearchTree <int>(elements);
int targetElement = elements[position];
PexAssert.IsTrue(bst.Remove(targetElement));
elements.Remove(targetElement);
if (elements.Contains(targetElement)) //Can happen when there are duplicate elements in the list
{
PexAssert.IsNotNull(bst.FindNode(targetElement));
}
else
{
PexAssert.IsNull(bst.FindNode(targetElement));
}
//Assert.AreEqual(19, bst.Root.Left.Value); //Cannot be generalized
PexAssert.AreEqual(elements.Count, bst.Count);
}
/// Summary
/// Time: 4 min 09 sec
/// Pattern: AAAA, State Relation
public void FindParentRootNodeTest([PexAssumeUnderTest] int[] elements)
{
PexAssume.IsTrue(elements.Length > 0);
BinarySearchTree <int> bst = new BinarySearchTree <int>(elements);
PexAssert.IsNull(bst.FindParent(bst.Root.Value));
}
public void RemoveSettingsPUT1([PexAssumeUnderTest] String[] name, [PexAssumeUnderTest] Object[] value)
{
PexAssume.IsTrue(value.Length < 255);
PexAssume.IsTrue(name.Length == value.Length);
for (int i = 0; i < value.Length; i++)
{
PexAssume.IsTrue(value[i] is String || value[i] is int);
PexAssume.IsNotNullOrEmpty(name[i]);
PexAssume.IsNotNull(value[i]);
//PexAssume.IsTrue(name[i].Contains("t"));
}
for (int i = 0; i < name.Length; i++)
{
storage.SaveSetting(name[i], value[i]);
}
for (int i = 0; i < name.Length; i++)
{
if (storage.GetSetting(name[i]) != null)
{
storage.RemoveSetting(name[i]);
PexAssert.IsNull(storage.GetSetting(name[i]), name[i] + " not removed");
}
}
}
/// Summary
/// Time: 1 min 03 sec
/// Pattern: AAA, State Relation
public void ClearTest([PexAssumeUnderTest] SinglyLinkedList <int> sll)
{
sll.Clear();
PexAssert.AreEqual(0, sll.Count);
PexAssert.IsNull(sll.Head);
PexAssert.IsNull(sll.Tail);
}
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 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 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 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);
}
}
/// 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 BinaryTreeNodeConstructorPUT(int value)
{
BinaryTreeNode <int> node = new BinaryTreeNode <int>(value);
PexAssert.AreEqual(value, node.Value);
PexAssert.IsNull(node.Left);
PexAssert.IsNull(node.Right);
}
public double?LongitudeGetTest([PexAssumeUnderTest] XmpTag target)
{
double?result = target.Longitude;
PexAssert.IsNull(result);
return(result);
// TODO: add assertions to method XmpTagTest.LongitudeGetTest(XmpTag)
}
/// Summary
/// Time: 1 min 15 sec
/// Pattern: AAA, State Relation, AllowedException
public void ClearTest(string[] elements)
{
BinarySearchTree <string> bst = new BinarySearchTree <string>(elements);
bst.Clear();
PexAssert.IsNull(bst.Root);
PexAssert.AreEqual(0, bst.Count);
}
public void ConstructorPUT(int value)
{
DoublyLinkedListNode <int> n = new DoublyLinkedListNode <int>(value);
PexAssert.AreEqual(value, n.Value);
PexAssert.IsNull(n.Previous);
PexAssert.IsNull(n.Next);
}
public void ClearPUT([PexAssumeUnderTest] IList <int> values)
{
DoublyLinkedList <int> dll = new DoublyLinkedList <int> (values);
dll.Clear();
PexAssert.IsNull(dll.Head);
PexAssert.IsNull(dll.Tail);
PexAssert.AreEqual(0, dll.Count);
}
public void SubstorageSettingsPUT1([PexAssumeUnderTest] MemorySettingsStorage storage1, [PexAssumeUnderTest] String subStorageName, [PexAssumeUnderTest] String settingName, [PexAssumeNotNull] Object settingValue)
{
ISettingsStorage sub = storage1.MakeChildStorage(subStorageName);
sub.SaveSetting(settingName, settingValue);
PexAssert.AreEqual(settingValue, sub.GetSetting(settingName));
sub.RemoveSetting(settingName);
PexAssert.IsNull(sub.GetSetting(settingName));
}
public void NextTest02()
{
SinglyLinkedListNode <int> s0 = new SinglyLinkedListNode <int>(0);
s0.Next = (SinglyLinkedListNode <int>)null;
this.NextTest(s0, 0);
PexAssert.IsNotNull((object)s0);
PexAssert.AreEqual <int>(0, s0.Value);
PexAssert.IsNull(s0.Next);
}
public void RemoveSettingsPUT1([PexAssumeUnderTest] MemorySettingsStorage storage1, [PexAssumeUnderTest] String settingName, [PexAssumeNotNull] Object settingValue)
{
PexAssume.IsTrue(settingName != null);
PexAssume.IsTrue(settingValue != null);
PexAssume.IsTrue(storage1.GetSetting(settingName) == null);
storage1.SaveSetting(settingName, settingValue);
storage1.RemoveSetting(settingName);
PexAssert.IsNull(storage1.GetSetting(settingName));
}
/// Summary
/// Time: 2 min 11 sec
/// Pattern: State Relation, AAAA
/// Combines two unit tests into one
public void RemoveOnlyNodeInListTest([PexAssumeUnderTest] SinglyLinkedList <int> actual, int newNode)
{
PexAssume.IsTrue(actual.Count == 0);
actual.AddFirst(newNode);
actual.Remove(newNode);
PexAssert.IsNull(actual.Head);
PexAssert.IsNull(actual.Tail);
}
public void SaveAndLoadSettings()
{
PexAssert.IsNull(storage.GetSetting("X"), "X is not null");
PexAssert.IsNull(storage.GetSetting("NAME"), "NAME is not null");
storage.SaveSetting("X", 5);
storage.SaveSetting("NAME", "Charlie");
PexAssert.AreEqual(5, storage.GetSetting("X"));
PexAssert.AreEqual("Charlie", storage.GetSetting("NAME"));
}
public void DefaultSettingsPUT1([PexAssumeUnderTest] String settingName, [PexAssumeNotNull] Object settingValue, [PexAssumeNotNull] Object defSettingValue)
{
PexAssume.IsTrue(settingName != null);
PexAssume.IsTrue(settingValue != null);
PexAssume.IsTrue(defSettingValue != null);
PexAssume.IsTrue(settingValue is string || settingValue is int || settingValue is bool); //|| settingValue is Enum);
PexAssume.IsTrue(defSettingValue is string || defSettingValue is int || defSettingValue is bool); // || defSettingValue is Enum);
PexAssert.IsNull(testGroup.GetSetting(settingName));
PexAssert.AreEqual(defSettingValue, testGroup.GetSetting(settingName, defSettingValue));
}
/// Summary
/// Time: 1 min 12 sec
/// Pattern: AAAA, State Relation
/// Generalized two unit tests "RemoveRootNoSubtreesTest and RemoveTreeHasNoItemsTest" into one PUT
public void RemoveRootNoSubtreesTest(int element1, int element2)
{
PexAssume.AreNotEqual(element1, element2);
BinarySearchTree <int> bst = new BinarySearchTree <int> {
element1
};
PexAssert.IsTrue(bst.Remove(element1));
PexAssert.IsNull(bst.Root);
PexAssert.AreEqual(0, bst.Count);
PexAssert.IsFalse(bst.Remove(element2));
}
public void RemoveSettings()
{
storage.SaveSetting("X", 5);
storage.SaveSetting("NAME", "Charlie");
storage.RemoveSetting("X");
PexAssert.IsNull(storage.GetSetting("X"), "X not removed");
PexAssert.AreEqual("Charlie", storage.GetSetting("NAME"));
storage.RemoveSetting("NAME");
PexAssert.IsNull(storage.GetSetting("NAME"), "NAME not removed");
}
public void DefaultSettings()
{
PexAssert.IsNull(testGroup.GetSetting("X"));
PexAssert.IsNull(testGroup.GetSetting("NAME"));
PexAssert.AreEqual(5, testGroup.GetSetting("X", 5));
PexAssert.AreEqual(6, testGroup.GetSetting("X", 6));
PexAssert.AreEqual("7", testGroup.GetSetting("X", "7"));
PexAssert.AreEqual("Charlie", testGroup.GetSetting("NAME", "Charlie"));
PexAssert.AreEqual("Fred", testGroup.GetSetting("NAME", "Fred"));
}
public void AgentReturnsProcessIdPUT101()
{
using (PexDisposableContext disposables = PexDisposableContext.Create())
{
RemoteTestAgent remoteTestAgent;
remoteTestAgent = RemoteTestAgentFactory.Create("\0");
disposables.Add((IDisposable)remoteTestAgent);
this.AgentReturnsProcessIdPUT1(remoteTestAgent);
disposables.Dispose();
PexAssert.IsNotNull((object)remoteTestAgent);
PexAssert.IsNull(remoteTestAgent.Agency);
}
}
public void BadSettingPUT207()
{
using (PexDisposableContext disposables = PexDisposableContext.Create())
{
SettingsGroup settingsGroup;
MemorySettingsStorage memorySettingsStorage = new MemorySettingsStorage();
settingsGroup = new SettingsGroup((ISettingsStorage)memorySettingsStorage);
disposables.Add((IDisposable)settingsGroup);
this.BadSettingPUT2(settingsGroup, "", "", false);
disposables.Dispose();
PexAssert.IsNotNull((object)settingsGroup);
PexAssert.IsNull(settingsGroup.Storage);
}
}
public void TopLevelSettings()
{
testGroup.SaveSetting("X", 5);
testGroup.SaveSetting("NAME", "Charlie");
PexAssert.AreEqual(5, testGroup.GetSetting("X"));
PexAssert.AreEqual("Charlie", testGroup.GetSetting("NAME"));
testGroup.RemoveSetting("X");
PexAssert.IsNull(testGroup.GetSetting("X"), "X not removed");
PexAssert.AreEqual("Charlie", testGroup.GetSetting("NAME"));
testGroup.RemoveSetting("NAME");
PexAssert.IsNull(testGroup.GetSetting("NAME"), "NAME not removed");
}
