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