// [PexMethod] public void TestClearRoutinesPUT1([PexAssumeUnderTest] String[] name, Object[] value, [PexAssumeUnderTest] String[] key) { //PexAssume.IsNotNull(mainKey); PexAssume.IsNotNull(value); PexAssume.IsTrue(key.Length >= 1); PexAssume.IsTrue(key.Length <= name.Length); PexAssume.IsTrue(name.Length == value.Length); for (int i = 0; i < name.Length; i++) { PexAssume.IsNotNullOrEmpty(name[i]); PexAssume.IsTrue(value[i] is String || value[i] is int); PexAssume.IsNotNull(value[i]); if (i < key.Length) { PexAssume.IsNotNull(key[i]); } } for (int i = 0; i < value.Length - key.Length; i++) { PexAssume.IsNotNull(value[i + key.Length]); PexAssume.IsNotNull(name[i + key.Length]); } /* for (int i = 0; i < key.Length; i++) * { * * }*/ NUnitRegistry.TestMode = true; using (RegistryKey mainKey = NUnitRegistry.CurrentUser){ mainKey.SetValue(name[0], value[0]); int k = 0; for (k = 1; k < key.Length; k++) { RegistryKey subKey = mainKey.CreateSubKey(key[k - 1]); subKey.SetValue(name[k], value[k]); } k = 0; for (int i = 0; i < value.Length - key.Length; i++) { RegistryKey subKey = mainKey.CreateSubKey(key[k]); subKey.SetValue(name[i + key.Length], value[i + key.Length]); k++; if (k == key.Length) { k = 0; } //PexAssume.IsNotNull(value[i + key.Length]); //PexAssume.IsNotNull(key[i + key.Length]); } NUnitRegistry.ClearTestKeys(); PexAssert.IsTrue(mainKey.ValueCount == 0); PexAssert.IsTrue(mainKey.SubKeyCount == 0); } }
public string[] KeywordsGetTest([PexAssumeUnderTest] XmpTag target, string[] keywords) { PexAssume.IsNotNull(keywords); PexAssume.IsTrue(!keywords.Contains(null)); target.Keywords = keywords; string[] result = target.Keywords; PexAssert.IsTrue(result.SequenceEqual(target.GetCollectionNode(XmpTag.DC_NS, "subject"))); return(result); // TODO: add assertions to method XmpTagTest.KeywordsGetTest(XmpTag) }
public void FocalLengthSetTest([PexAssumeUnderTest] XmpTag target, double value) { PexAssume.IsNotNull(value); PexAssume.IsTrue(value != 0); target.FocalLength = value; double result = target.GetRationalNode(XmpTag.EXIF_NS, "FocalLength").Value; PexAssert.AreEqual(result, value, 0.001); // TODO: add assertions to method XmpTagTest.FocalLengthSetTest(XmpTag, Nullable`1<Double>) }
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 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 void GetFirst_WhenCalled_CountStaysTheSame <TPriority, TValue>( [PexAssumeUnderTest] BinaryHeap <TPriority, TValue> heap) { PexAssume.IsTrue(heap.Count > 0); var initialCount = heap.Count; heap.GetFirst(); Assert.AreEqual(initialCount, heap.Count); }
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(); }
/// Summary /// Time: 2 min 55 sec /// Pattern: AAAA, Round Trip /// Generalizes three unit tests "FindNodeValidLeftChildTest, FindNodeValidRightChildTest, FindNodeNotInBstTest" into one PUT public void FindNodeValidLeftChildTest([PexAssumeUnderTest] List <int> elements, int position, int notExistingElement) { PexAssume.IsTrue(position >= 0 && position < elements.Count); PexAssume.IsFalse(elements.Contains(notExistingElement)); BinarySearchTree <int> bst = new BinarySearchTree <int>(elements); PexAssert.IsNotNull(bst.FindNode(elements[position])); PexAssert.AreEqual(elements[position], bst.FindNode(elements[position]).Value); PexAssume.IsNull(bst.FindNode(notExistingElement)); }
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); }
/// Summary /// Time: 1 min 27 sec /// Pattern: Manual Output Review, AAAA (A case of partial generalization) /// Difficulties in generalization - loss of test oracle /// Failing tests : Also raises NullPointerException but the reason is the same as the test RemoveNodeWithBothSubtreesTest\ /// Generalizes six unit tests RemoveNodeWithLeftSubtreeOnlyChildGreaterThanOrEqualToParentTest and /// RemoveNodeWithLeftSubtreeOnlyChildLessThanParentTest /// RemoveNodeWithRightSubtreeOnlyChildLessThanParentTest /// RemoveNodeWithRightSubtreeOnlyChildGreaterThanOrEqualToParentTest /// RemoveLeafValueGreaterThanOrEqualToParentTest /// RemoveLeafValueLessThanParentTest public void RemoveNodeWithLeftSubtreeOnlyChildGreaterThanOrEqualToParentTest([PexAssumeUnderTest] int[] elements, int position) { PexAssume.IsTrue(position >= 0 && position < elements.Length); BinarySearchTree <int> bst = new BinarySearchTree <int>(elements); PexAssert.IsTrue(bst.Remove(elements[position])); PexObserve.ValueForViewing <int[]>("Binary Search Contents", bst.ToArray()); //Assert.AreEqual(61, bst.Root.Right.Right.Right.Value); //Cannot be generalized //Assert.AreEqual(9, bst.Count); }
/// 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 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 int patternIndexTest(string subject, string pattern) { // Formar cadenas sin el caracter de escape '\' PexAssume.IsTrue(subject != null && pattern != null); PexAssume.IsTrue(Regex.IsMatch(subject, "^[a-zA-Z0-9]*$")); PexAssume.IsTrue(Regex.IsMatch(pattern, "^[a-zA-Z0-9]*$")); int result = global::EjerciciosPex.EjerciciosPex.patternIndex(subject, pattern); return(result); }
/// 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 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) }
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 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)); }
/// 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); }
//[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)); }
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 string Puzzle(int[] a) { PexAssume.IsNotNull(a); PexAssume.IsTrue(a.Length >= 2 & a.Length <= 20); foreach (int v in a) { PexAssume.IsTrue(v >= -50 & v <= 50); } int result = global::Program.Puzzle(a); return(PexSymbolicValue.GetPathConditionString() + " RET_DIV " + PexSymbolicValue.ToString <int>(result));; }
/// Summary /// Time: 5 min 20 sec /// Pattern: AAA, State Relation, Round Trip public void AddAfterMiddleNodeTest([PexAssumeUnderTest] SinglyLinkedList <int> sll, int newelement) { PexAssume.IsTrue(sll.Count > 1); int prevHead = sll.Head.Value; int prevCount = sll.Count; sll.AddAfter(sll.Head.Next, newelement); PexAssert.AreEqual(newelement, sll.Head.Next.Next.Value); PexAssert.AreEqual(prevHead, sll.Head.Value); PexAssert.AreEqual(prevCount + 1, sll.Count); }
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 void TopLevelSettingsPUT3([PexAssumeUnderTest] SettingsGroup testGroup1, [PexAssumeUnderTest] String settingName, [PexAssumeUnderTest] Object settingValue) { PexAssume.IsTrue(settingName != null); PexAssume.IsTrue(settingValue != null); DelegateHandler dhObj = new DelegateHandler(testGroup1); PexAssume.IsTrue(testGroup1.GetSetting(settingName) != null); testGroup1.SaveSetting(settingName, testGroup1.GetSetting(settingName)); testGroup1.RemoveSetting(settingName); PexAssume.IsNull(testGroup1.GetSetting(settingName)); }
[PexMethod] // !New_x == New_dCount !New_y == New_dCoun public void testValueSameAsCountAfterAdding([PexAssumeUnderTest] Dictionary.Dictionary <int, int> d, int x, int y) { PexAssume.IsTrue(!d.ContainsKey(x)); bool hit = true; d.Add(x, y); if (y == d.Count) { hit = false; } PexAssert.IsTrue(hit); }
[PexMethod] // !New_x == New_dCount !New_y == New_dCoun public void testKeySameAsCountAfterAddingWithValueAlreadyInDict([PexAssumeUnderTest] Dictionary.Dictionary <int, int> d, int x, int y) { PexAssume.IsTrue(!d.ContainsKey(x) && d.ContainsValue(y)); bool hit = true; d.Add(x, y); if (x == d.Count) { hit = false; } PexAssert.IsTrue(hit); }