public void Test_Append <T>([PexAssumeNotNull] T[] arr1, T t, [PexAssumeNotNull] T[] arr2)
{
var seq = RandomAccessSequence.FromEnumerable(arr1);
Assert2.SequenceEqual(arr1.Append(t), seq | t);
Assert2.SequenceEqual(arr1.Concat(arr2), seq.AppendRange(arr2));
}
public void Test_Prepend <T>([PexAssumeNotNull] T[] arr1, T t, [PexAssumeNotNull] T[] arr2)
{
var seq = RandomAccessSequence.FromEnumerable(arr1);
Assert2.SequenceEqual(t.Cons(arr1.AsEnumerable()), t | seq);
Assert2.SequenceEqual(arr2.Concat(arr1), seq.PrependRange(arr2));
}
public void Test_Concat <T>([PexAssumeNotNull] T[] arr1, [PexAssumeNotNull] T[] arr2)
{
var seq1 = RandomAccessSequence.FromEnumerable(arr1);
var seq2 = RandomAccessSequence.FromEnumerable(arr2);
Assert2.SequenceEqual(seq1.AsEnumerable().Concat(seq2), seq1 + seq2);
}
public void Test_ConcatWithEmpty <T>([PexAssumeNotNull] T[] arr)
{
var seq = RandomAccessSequence.FromEnumerable(arr);
Assert2.SequenceEqual(seq + RandomAccessSequence <T> .Empty, seq);
Assert2.SequenceEqual(RandomAccessSequence <T> .Empty + seq, seq);
}
public static int AddToEndRandomAccessSequence(IEnumerable <int> input)
{
var list = RandomAccessSequence.Empty <int>();
list = list.AppendRange(input);
return(list.Count);
}
public void Test_Indexing <T>([PexAssumeNotNull] T[] arr, int i)
{
var seq = RandomAccessSequence.FromEnumerable(arr);
PexAssume.IsTrue(i >= 0);
PexAssume.IsTrue(i < arr.Length);
Assert.Equal(arr[i], seq[i]);
}
public void Test_HeadAndTailOfEmptySequence()
{
var empty = RandomAccessSequence.Empty <int>();
Assert.Throws <EmptyEnumerableException>(() => { var a = empty.Head; });
Assert.Throws <EmptyEnumerableException>(() => { var a = empty.Tail; });
Assert.Throws <EmptyEnumerableException>(() => { var a = empty.Init; });
Assert.Throws <EmptyEnumerableException>(() => { var a = empty.Last; });
}
private static int AddToBeginningRandomAccessSequence(IEnumerable <int> input)
{
var list = RandomAccessSequence.Empty <int>();
foreach (var i in input)
{
list = list.Prepend(i);
}
return(list.Count);
}
public void Test_SplitAt <T>([PexAssumeNotNull] T[] arr, int i)
{
var seq = RandomAccessSequence.FromEnumerable(arr);
PexAssume.IsTrue(i >= 0);
PexAssume.IsTrue(i < arr.Length);
var split = seq.SplitAt(i);
Assert2.SequenceEqual(arr.Take(i), split.Item1);
Assert2.SequenceEqual(arr.Take(i), seq.Take(i));
Assert2.SequenceEqual(arr.Skip(i), split.Item2);
Assert2.SequenceEqual(arr.Skip(i), seq.Skip(i));
}
public void Test_SetAt <T>([PexAssumeNotNull] T[] arr, int i, T newValue)
{
var seq = RandomAccessSequence.FromEnumerable(arr);
PexAssume.IsTrue(i >= 0);
PexAssume.IsTrue(i < seq.Count);
var newSeq = seq.SetAt(i, newValue);
var splitOld = seq.SplitAt(i);
var splitNew = newSeq.SplitAt(i);
Assert2.SequenceEqual(splitOld.Item1, splitNew.Item1);
Assert.Equal(newValue, splitNew.Item2.Head);
Assert2.SequenceEqual(splitOld.Item2.Tail, splitNew.Item2.Tail);
}
public void Test_HeadAndTailOfNonEmptySequence <T>([PexAssumeNotNull] T[] arr)
{
PexAssume.IsNotNullOrEmpty(arr);
var seq0 = RandomAccessSequence.FromEnumerable(arr);
var seq = seq0;
foreach (var t in arr)
{
Assert.Equal(t, seq.Head);
seq = seq.Tail;
}
Assert.Empty(seq);
seq = seq0;
foreach (var t in arr.Reverse())
{
Assert.Equal(t, seq.Last);
seq = seq.Init;
}
Assert.Empty(seq);
}
public void Test_Enumerate <T>([PexAssumeNotNull] T[] arr)
{
Assert2.SequenceEqual(arr, RandomAccessSequence.FromEnumerable(arr));
}
public void Test_IsEmptyWorksCorrectly <T>(T[] arr)
{
Assert.True(RandomAccessSequence.Empty <int>().IsEmpty);
PexAssume.IsNotNullOrEmpty(arr);
Assert.False(RandomAccessSequence.FromEnumerable(arr).IsEmpty);
}
public void Test_Reverse <T>([PexAssumeNotNull] T[] arr)
{
var seq = RandomAccessSequence.FromEnumerable(arr);
Assert2.SequenceEqual(seq.AsEnumerable().Reverse(), seq.Reverse());
}
/// <summary>
/// Overload of <see cref="IsIndexAndCountInRange{T,TSeq}"/> for type inference.
/// </summary>
public static Validation IsIndexAndCountInRange <T>(this Validation validation, RandomAccessSequence <T> seq, int index, int count, string indexParamName, string countParamName)
{
return(validation.IsIndexAndCountInRange <T, RandomAccessSequence <T> >(seq, index, count, indexParamName, countParamName));
}
/// <summary>
/// Overload of <see cref="IsIndexInRange{T,TSeq}"/> for type inference.
/// </summary>
public static Validation IsIndexInRange <T>(this Validation validation, RandomAccessSequence <T> seq, int index, string paramName)
{
return(validation.IsIndexInRange <T, RandomAccessSequence <T> >(seq, index, paramName));
}
