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);
}
public int[][] Puzzle(int x, int y)
{
PexAssume.IsTrue(1 <= x & x <= 8 & 1 <= y & y <= 8);
if (x == 5 & y == 1 | x == 3 & y == 8)
{
; // Hint to user
}
int[][] result = global::Program.Puzzle(x, y);
return(PexSymbolicValue.GetPathConditionString() + " RET_DIV " + PexSymbolicValue.ToString <int[][]>(result));
}
public static SinglyLinkedList <string> Create(
SinglyLinkedListNode <string> node_singlyLinkedListNode,
string[] items
)
{
PexAssume.IsNotNull(items);
SinglyLinkedList <string> singlyLinkedList = new SinglyLinkedList <string>(items);
return(singlyLinkedList);
}
public static SinglyLinkedList <int> Create(
SinglyLinkedListNode <int> node_singlyLinkedListNode,
int[] elements
)
{
PexAssume.IsNotNull(elements);
SinglyLinkedList <int> singlyLinkedList = new SinglyLinkedList <int>(elements);
return(singlyLinkedList);
}
public void RepeatEmptyEnumerable <T>([PexAssumeNotNull] T[] value, int count)
{
PexAssume.IsTrue(value.Length == 0);
var enumerable = EnumerableEx.Repeat((IEnumerable <T>)value);
var enumerator = enumerable.GetEnumerator();
enumerator.MoveNext();
PexAssert.Fail();
}
public string CreatorGetTest([PexAssumeUnderTest] XmpTag target, string creator)
{
PexAssume.IsNotNull(creator);
target.Creator = creator;
string result = target.Creator;
PexAssert.AreEqual(target.GetCollectionNode(XmpTag.DC_NS, "creator")[0], result);
return(result);
// TODO: add assertions to method XmpTagTest.CreatorGetTest(XmpTag)
}
public DateTime?DateTimeGetTest([PexAssumeUnderTest] XmpTag target, DateTime datetime)
{
PexAssume.IsNotNull(datetime);
target.DateTime = datetime;
DateTime?result = target.DateTime;
PexAssert.AreEqual(result.ToString(), target.GetTextNode(XmpTag.XAP_NS, "CreateDate").ToString());
return(result);
// TODO: add assertions to method XmpTagTest.DateTimeGetTest(XmpTag)
}
public void StorageHasCorrectKeyPUT1([PexAssumeUnderTest] String testVar)
{
PexAssume.IsTrue(testVar.Contains("t"));
RegistryKey key = Registry.CurrentUser;
RegistryKey subkey = key.CreateSubKey(testVar);
RegistrySettingsStorage storage = new RegistrySettingsStorage(subkey);
testVar = "HKEY_CURRENT_USER\\" + testVar;
PexAssert.IsTrue(storage.StorageKey.Name.ToLower().Equals(testVar.ToLower()));
}
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));
}
public XmpNode FindNodeTest([PexAssumeUnderTest] XmpTag target, string value)
{
PexAssume.IsNotNull(value);
target.Copyright = value;
XmpNode result = target.FindNode(XmpTag.DC_NS, "rights");
PexAssert.AreEqual(result.Value, target.Copyright);
return(result);
// TODO: add assertions to method XmpTagTest.FindNodeTest(XmpTag, String, String)
}
public double?FNumberGetTest([PexAssumeUnderTest] XmpTag target, double fNumber)
{
target.FNumber = fNumber;
double?result = target.FNumber;
PexAssume.IsNotNull(result);
PexAssert.AreEqual(result, target.GetRationalNode(XmpTag.EXIF_NS, "FNumber"));
return(result);
// TODO: add assertions to method XmpTagTest.FNumberGetTest(XmpTag)
}
public void MakeSubStoragesPUT1([PexAssumeUnderTest] String subName)
{
PexAssume.IsTrue(subName.Contains("t"));
String test1 = "HKEY_CURRENT_USER\\" + testKeyName + "\\" + subName;
RegistrySettingsStorage sub1 = (RegistrySettingsStorage)storage.MakeChildStorage(subName);
Console.WriteLine(test1.ToLower());
Console.WriteLine(sub1.StorageKey.Name.ToLower());
PexAssert.IsNotNull(sub1, "Sub1 is null");
PexAssert.IsTrue(sub1.StorageKey.Name.ToLower().Equals(test1.ToLower()));
}
/// Summary
/// Time: 1 min 3 sec
/// Pattern: AAAA, Allowed Exception
public void AddEdgeSourceNotFound([PexAssumeUnderTest] AdjacencyGraph g)
{
IVertex v = RandomGraph.Vertex(g, new Random());
IVertex source = RandomGraph.Vertex(g, new Random());
PexAssume.IsTrue(v != source);
g.RemoveVertex(source);
IEdge e = g.AddEdge(source, v);
PexAssert.IsTrue(false); //Should not be reached
}
public string CommentGetUserCommentTest([PexAssumeUnderTest] XmpTag target, string value)
{
PexAssume.IsNotNull(value);
PexAssume.IsNull(target.GetLangAltNode(XmpTag.DC_NS, "description"));
target.SetLangAltNode(XmpTag.EXIF_NS, "UserComment", value);;
string result = target.Comment;
PexAssert.AreEqual(result, target.GetLangAltNode(XmpTag.EXIF_NS, "UserComment"));
return(result);
// TODO: add assertions to method XmpTagTest.CommentGetTest(XmpTag)
}
public void ReplaceFromTest([PexAssumeUnderTest] XmpTag target, XmpTag tag, string ns, string name, string value)
{
PexAssume.IsNotNull(tag);
PexAssume.IsNotNull(ns);
PexAssume.IsNotNull(name);
PexAssume.IsNotNull(value);
tag.SetTextNode(ns, name, value);
target.ReplaceFrom(tag);
PexAssert.AreEqual(value, target.GetTextNode(ns, name));
// TODO: add assertions to method XmpTagTest.ReplaceFromTest(XmpTag, XmpTag)
}
public ImageOrientation OrientationGetTest([PexAssumeUnderTest] XmpTag target, ImageOrientation value)
{
PexAssume.IsNotNull(value);
PexAssume.IsTrue((uint)value >= 1U && (uint)value <= 8U);
target.Orientation = value;
ImageOrientation result = target.Orientation;
PexAssert.AreEqual(result, (ImageOrientation)target.GetUIntNode(XmpTag.TIFF_NS, "Orientation"));
return(result);
// TODO: add assertions to method XmpTagTest.OrientationGetTest(XmpTag)
}
/// Summary
/// Time: 2 min 20 sec
/// Pattern: AAA, State Relation, Round Trip
public void AddBeforeHeadTest([PexAssumeUnderTest] SinglyLinkedList <string> sll, string newElement)
{
PexAssume.IsTrue(sll.Count > 0);
string prevValue = sll.Head.Value;
int prevCount = sll.Count;
sll.AddBefore(sll.Head, newElement);
PexAssert.AreEqual(newElement, sll.Head.Value);
PexAssert.AreEqual(prevValue, sll.Head.Next.Value);
PexAssert.AreEqual(prevCount + 1, sll.Count);
}
/// Summary
/// Time: 1 min 8 sec
/// Pattern: AAAA, Allowed Exception
public void AddEdgeTargetNotFound([PexAssumeUnderTest] AdjacencyGraph g)
{
IVertex v = RandomGraph.Vertex(g, new Random());
IVertex target = RandomGraph.Vertex(g, new Random());
PexAssume.IsTrue(v != target);
g.RemoveVertex(target);
IEdge e = g.AddEdge(v, target);
PexAssert.IsTrue(false); //Should not be reached
}
public void BadSettingPUT2([PexAssumeUnderTest] SettingsGroup testGroup1, [PexAssumeUnderTest] String settingName, [PexAssumeNotNull] Object settingValue, bool defSettingValue)
{
PexAssume.IsTrue(settingName != null);
PexAssume.IsTrue(settingValue != null);
//PexAssume.IsTrue(defSettingValue != null);
PexAssume.IsTrue(settingValue is string);
PexAssume.IsTrue(!settingValue.Equals("True") && !settingValue.Equals("False"));
testGroup1.SaveSetting(settingName, settingValue);
PexAssert.AreEqual(defSettingValue, testGroup1.GetSetting(settingName, defSettingValue));
}
//[PexFactoryMethod(typeof(CategoryExpression))]
public static CategoryExpression Create([PexAssumeUnderTest] String s)
{
Regex ex = new Regex("*;*");
//a;b -
PexAssume.IsTrue(ex.IsMatch(s));// && (s.Contains(",") && s.Contains(";")));
CategoryExpression categoryExpression = new CategoryExpression(s);
return(categoryExpression);
}
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: 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 static Stack Create(object[] objs)
{
PexAssume.IsTrue(objs.Length < 15);
Stack stack = new Stack();
for (int i = 0; i < objs.Length; i++)
{
stack.Push(objs[i]);
}
return(stack);
}
public int CheckOriginal(int a, int b, int c)
{
PexAssume.IsTrue(MaxValuesAssumptions(a, b, c));
int result = TriangleClassification.ClassifyOriginal(a, b, c);
bool isValid = TriangleClassification.CheckResult(a, b, c, result);
Evaluation.ValidAssert(isValid);
return(result);
}
public static ProjectConfig Create([PexAssumeUnderTest] String category, [PexAssumeUnderTest] String dllName)
{
PexAssume.IsTrue(dllName.Length > 0);
PexAssume.IsTrue(category.Equals("Debug") || category.Equals("Release"));
ProjectConfig config1 = new ProjectConfig(category);
config1.BasePath = "bin" + Path.DirectorySeparatorChar + category;
config1.Assemblies.Add(Path.GetFullPath("bin" + Path.DirectorySeparatorChar + category + Path.DirectorySeparatorChar + dllName));
config1.Assemblies.Add(Path.GetFullPath("bin" + Path.DirectorySeparatorChar + category + Path.DirectorySeparatorChar + dllName));
return(config1);
}
public static Stack.Stack <int> Create([PexAssumeNotNull] int[] elems)
{
//PexAssume.AreDistinctValues(elems);
PexAssume.TrueForAll(elems, e => e <= -6 || e > -6);
//PexAssume.TrueForAll(0, elems.Length, _i => elems[_i] < -2 || elems[_i] >= 2);
Stack.Stack <int> ret = new Stack.Stack <int>();
for (int i = 0; i < elems.Length; i++)
{
ret.Push(elems[i]);
}
return(ret);
}
public string FooTest(
[PexAssumeUnderTest] Bar target,
Foo iksDee,
bool b
)
{
PexAssume.IsNotNull(iksDee);
string result = target.Foo(iksDee, b);
return(result);
// TODO: add assertions to method BarTest.FooTest(Bar, Foo, Boolean)
}
/// 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 static ClientAPI.AbstractStack CreateAbstractStackWithElements(int top, int count, bool contains)
{
/*TODO: unclear how to maintain invariant count == 0 => top is undefined */
//System.Nullable<int>();
int oldTop = top;
PexAssume.IsTrue((count == 0 ? (top == -1 && contains == false) : oldTop == top));
//PexAssume.IsTrue(top != 0);
AbstractStack s1 = new AbstractStack(top, count, contains);
return(s1);
}
public static Stack.Stack <int> Create([PexAssumeNotNull] int[] elems)
{
//PexAssume.IsTrue(elems != null && elems.Length < 11);
PexAssume.TrueForAll(0, elems.Length, _i => elems[_i] > -11 && elems[_i] < 11);
Stack.Stack <int> ret = new Stack.Stack <int>(elems.Length + 2);// DataStructure has big enough capacity for Commutativity Test
for (int i = 0; i < elems.Length; i++)
{
// For stack, add any element.
ret.Push(elems[i]);
}
return(ret);
}
