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