public void InsertManyAndEnumerateUntyped <TPriority, TValue>(
[PexAssumeUnderTest] BinaryHeap <TPriority, TValue> target,
[PexAssumeNotNull] KeyValuePair <TPriority, TValue>[] kvs)
{
foreach (var kv in kvs)
{
target.Add(kv.Key, kv.Value);
}
foreach (KeyValuePair <TPriority, TValue> kv in (IEnumerable)target)
{
;
}
}
public void InsertAndEnumerate <TPriority, TValue>(
[PexAssumeUnderTest] BinaryHeap <TPriority, TValue> target,
[PexAssumeNotNull] KeyValuePair <TPriority, TValue>[] kvs)
{
var dic = new Dictionary <TPriority, TValue>();
foreach (var kv in kvs)
{
target.Add(kv.Key, kv.Value);
dic[kv.Key] = kv.Value;
}
PexAssert.TrueForAll(target, kv => dic.ContainsKey(kv.Key));
}
public void CurrentAfterMoveNextFinished <TPriority, TValue>(
[PexAssumeUnderTest] BinaryHeap <TPriority, TValue> target,
KeyValuePair <TPriority, TValue> kv)
{
target.Add(kv.Key, kv.Value);
PexAssert.Throws <InvalidOperationException>(delegate
{
var enumerator = target.GetEnumerator();
while (enumerator.MoveNext())
{
;
}
var current = enumerator.Current;
});
}
public void InsertAndRemoveAt <TPriority, TValue>(
[PexAssumeUnderTest] BinaryHeap <TPriority, TValue> target,
[PexAssumeNotNull] KeyValuePair <TPriority, TValue>[] kvs,
int removeAtIndex)
{
foreach (var kv in kvs)
{
target.Add(kv.Key, kv.Value);
}
var count = target.Count;
var removed = target.RemoveAt(removeAtIndex);
Assert.AreEqual(count - 1, target.Count);
AssertInvariant <TPriority, TValue>(target);
}
private void InsertAndRemoveAt <TPriority, TValue>(
BinaryHeap <TPriority, TValue> target,
KeyValuePair <TPriority, TValue>[] kvs,
int removeAtIndex)
{
foreach (var kv in kvs)
{
target.Add(kv.Key, kv.Value);
}
var count = target.Count;
var removed = target.RemoveAt(removeAtIndex);
Assert.Equal(count - 1, target.Count);
AssertInvariant <TPriority, TValue>(target);
}
public void InsertAndRemoveAtAll <TPriority, TValue>(
[PexAssumeUnderTest] BinaryHeap <TPriority, TValue> target,
[PexAssumeNotNull] KeyValuePair <TPriority, TValue>[] kvs)
{
foreach (var kv in kvs)
{
target.Add(kv.Key, kv.Value);
}
var call = PexChoose.FromCall(this);
for (int i = target.Count - 1; i > -1; ++i)
{
target.RemoveAt(call.ValueFromRange(i.ToString(), 0, target.Count - 1));
AssertInvariant <TPriority, TValue>(target);
}
}
public void Operations <TPriority, TValue>(
[PexAssumeUnderTest] BinaryHeap <TPriority, TValue> target,
[PexAssumeNotNull] KeyValuePair <bool, TPriority>[] values)
{
foreach (var value in values)
{
if (value.Key)
{
target.Add(value.Value, default(TValue));
}
else
{
var min = target.RemoveMinimum();
}
AssertInvariant <TPriority, TValue>(target);
}
}
public PriorityQueue(
IDictionary <TVertex, TDistance> distances,
Comparison <TDistance> distanceComparison
)
{
if (distances == null)
{
throw new ArgumentNullException("distances");
}
if (distanceComparison == null)
{
throw new ArgumentNullException("distanceComparison");
}
this.distances = distances;
this.heap = new BinaryHeap <TDistance, TVertex>(distanceComparison);
}
private void Operations <TPriority, TValue>(
BinaryHeap <TPriority, TValue> target,
KeyValuePair <bool, TPriority>[] values)
{
foreach (var value in values)
{
if (value.Key)
{
target.Add(value.Value, default(TValue));
}
else
{
var min = target.RemoveMinimum();
}
AssertInvariant <TPriority, TValue>(target);
}
}
void IDisposable.Dispose()
{
this.owner = null;
this.items = null;
}
public void ConstructorWithNullComparison()
{
var target = new BinaryHeap <int, int>(0, null);
}
public void Constructor()
{
var target = new BinaryHeap <int, int>();
AssertInvariant <int, int>(target);
}
public static BinaryHeap <int, int> Create(int capacity)
{
var heap = new BinaryHeap <int, int>(capacity, (i, j) => i.CompareTo(j));
return(heap);
}
public void DefaultConstructorTest()
{
var target = new BinaryHeap <int, int>();
AssertInvariant <int, int>(target);
}
