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