public IEnumerable <IEnumerable <TEdge> > HoffmanPavleyRankedShortestPath <TVertex, TEdge>(
[PexAssumeNotNull] IBidirectionalGraph <TVertex, TEdge> g,
[PexAssumeNotNull] Dictionary <TEdge, double> edgeWeights,
TVertex rootVertex,
TVertex goalVertex,
int pathCount
)
where TEdge : IEdge <TVertex>
{
//GraphConsoleSerializer.DisplayGraph((IEdgeListGraph<TVertex, TEdge>)g);
PexAssert.TrueForAll(g.Edges, edgeWeights.ContainsKey);
var target = new HoffmanPavleyRankedShortestPathAlgorithm <TVertex, TEdge>(g, e => edgeWeights[e]);
target.ShortestPathCount = pathCount;
target.Compute(rootVertex, goalVertex);
double lastWeight = double.MinValue;
foreach (var path in target.ComputedShortestPaths)
{
TestConsole.WriteLine("path: {0}", Enumerable.Sum(path, e => edgeWeights[e]));
double weight = Enumerable.Sum(path, e => edgeWeights[e]);
Assert.IsTrue(lastWeight <= weight, "{0} <= {1}", lastWeight, weight);
Assert.AreEqual(rootVertex, Enumerable.First(path).Source);
Assert.AreEqual(goalVertex, Enumerable.Last(path).Target);
Assert.IsTrue(EdgeExtensions.IsPathWithoutCycles <TVertex, TEdge>(path));
lastWeight = weight;
}
return(target.ComputedShortestPaths);
}
public void Test_ReplaceSingleElement<T>([PexAssumeNotNull] T[] array, T newValue, int i) {
var vector = Vector.New(array);
PexAssume.IsTrue(i >= 0);
var vector2 = vector.SetAt(i, newValue);
Assert.True(vector2.Count >= vector.Count);
Assert.Equal(newValue, vector2[i]);
PexAssert.TrueForAll(0, vector2.Count, j => j == i || Equals(vector2[j], vector[j]));
} // ReplaceSingleElement(i, j)
public void Test_ExtractAll<T>([PexAssumeNotNull] T[] array, T item) where T : IComparable<T> {
var seq = OrderedSequence.FromEnumerable(array);
var split = seq.ExtractAll(item);
Assert2.SequenceEqual(seq, split.Item1.Concat(split.Item2).Concat(split.Item3));
PexAssert.TrueForAll(split.Item1, t => t.CompareTo(item) < 0);
PexAssert.TrueForAll(split.Item2, t => t.CompareTo(item) == 0);
PexAssert.TrueForAll(split.Item3, t => t.CompareTo(item) > 0);
Assert2.SequenceEqual(split.Item1, seq.LessThan(item));
Assert2.SequenceEqual(split.Item1.Concat(split.Item2), seq.AtMost(item));
Assert2.SequenceEqual(split.Item2.Concat(split.Item3), seq.AtLeast(item));
Assert2.SequenceEqual(split.Item3, seq.GreaterThan(item));
}
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 Test_Split<T>([PexAssumeNotNull] T[] array, T item, bool equalGoLeft) where T : IComparable<T> {
var seq = OrderedSequence.FromEnumerable(array);
var split = seq.Split(item, equalGoLeft);
Assert2.SequenceEqual(seq, split.Item1 + split.Item2);
if (equalGoLeft) {
PexAssert.TrueForAll(split.Item1, t => t.CompareTo(item) <= 0);
PexAssert.TrueForAll(split.Item2, t => t.CompareTo(item) > 0);
}
else {
PexAssert.TrueForAll(split.Item1, t => t.CompareTo(item) < 0);
PexAssert.TrueForAll(split.Item2, t => t.CompareTo(item) >= 0);
}
}
public void ReplaceTextSpans_ArbitraryTextSpans_NoCrash()
{
var tree1 = BBCodeTestUtil.GetAnyTree();
var chosenTexts = new List <string>();
var tree2 = BBCode.ReplaceTextSpans(tree1, txt =>
{
var count = PexChoose.ValueFromRange("count", 0, 3);
var indexes = PexChoose.Array <int>("indexes", count);
PexAssume.TrueForAll(0, count, i => indexes[i] >= 0 && indexes[i] <= txt.Length && (i == 0 || indexes[i - 1] < indexes[i]));
return
(Enumerable.Range(0, count)
.Select(i =>
{
var maxIndex = i == count - 1 ? txt.Length : indexes[i + 1];
var text = PexChoose.ValueNotNull <string>("text");
chosenTexts.Add(text);
return new TextSpanReplaceInfo(indexes[i], PexChoose.ValueFromRange("count", 0, indexes[i] - maxIndex + 1), new TextNode(text));
})
.ToArray());
}, null);
var bbCode = tree2.ToBBCode();
PexAssert.TrueForAll(chosenTexts, s => bbCode.Contains(s));
}
