public void Constructor()
{
var builder = new LargeArrayBuilder <T>(initialize: true);
Assert.Equal(0, builder.Count);
Assert.Same(Array.Empty <T>(), builder.ToArray());
}
public void ToArray_ArrayPool_Must_Succeed(int count)
{
// Arrange
var pool = ArrayPool <int> .Shared;
var expected = Enumerable
.Range(0, count)
.ToArray();
using var builder = new LargeArrayBuilder <int>(ArrayPool <int> .Shared);
for (var index = 0; index < count; index++)
{
builder.Add(expected[index]);
}
// Act
var result = builder.ToArray(pool);
try
{
// Assert
_ = result.Must()
.BeEqualTo(expected);
}
finally
{
pool.Return(result.Array);
}
}
public static T[] MyToArray <T>(this IEnumerable <T> enumerable)
{
var builder = new LargeArrayBuilder <T>(true);
builder.AddRange(enumerable);
return(builder.ToArray());
}
public TResult[] ToArray()
{
var builder = new LargeArrayBuilder <TResult>(initialize: true);
foreach (TSource element in _source)
{
builder.AddRange(_selector(element));
}
return(builder.ToArray());
}
public TResult[] ToArray()
{
var builder = new LargeArrayBuilder <TResult>(initialize: true);
foreach (TSource item in _source)
{
builder.Add(_selector(item));
}
return(builder.ToArray());
}
private TResult[] LazyToArray()
{
Debug.Assert(_source.GetCount(onlyIfCheap: true) == -1);
var builder = new LargeArrayBuilder <TResult>(initialize: true);
foreach (TSource input in _source)
{
builder.Add(_selector(input));
}
return(builder.ToArray());
}
public void AddRange(IEnumerable <T> seed)
{
var builder = new LargeArrayBuilder <T>(initialize: true);
// Call AddRange multiple times and verify contents w/ each iteration.
for (int i = 1; i <= 10; i++)
{
builder.AddRange(seed);
IEnumerable <T> expected = Enumerable.Repeat(seed, i).SelectMany(s => s);
Assert.Equal(expected, builder.ToArray());
}
}
public void MaxCapacity(IEnumerable <T> seed, int maxCapacity)
{
var builder = new LargeArrayBuilder <T>(maxCapacity);
for (int i = 0; i < maxCapacity; i++)
{
builder.Add(seed.ElementAt(i));
int count = i + 1;
Assert.Equal(count, builder.Count);
Assert.Equal(seed.Take(count), builder.ToArray());
}
}
public TSource[] ToArray()
{
var builder = new LargeArrayBuilder <TSource>(_source.Length);
foreach (TSource item in _source)
{
if (_predicate(item))
{
builder.Add(item);
}
}
return(builder.ToArray());
}
public TResult[] ToArray()
{
var builder = new LargeArrayBuilder <TResult>(_source.Count);
for (int i = 0; i < _source.Count; i++)
{
TSource item = _source[i];
if (_predicate(item))
{
builder.Add(_selector(item));
}
}
return(builder.ToArray());
}
public virtual TSource[] ToArray()
{
var builder = new LargeArrayBuilder <TSource>(initialize: true);
for (int i = 0; ; i++)
{
IEnumerable <TSource> source = GetEnumerable(i);
if (source == null)
{
break;
}
builder.AddRange(source);
}
return(builder.ToArray());
}
public void CopyTo(IEnumerable <T> seed, int index, int count)
{
var array = new T[seed.Count()];
var builder = new LargeArrayBuilder <T>(initialize: true);
builder.AddRange(seed);
builder.CopyTo(array, index, count);
// Ensure we don't copy out of bounds by verifying contents outside the copy area, too.
IEnumerable <T> prefix = array.Take(index);
IEnumerable <T> suffix = array.Skip(index + count);
IEnumerable <T> actual = array.Skip(index).Take(count);
Assert.Equal(Enumerable.Repeat(default(T), index), prefix);
Assert.Equal(Enumerable.Repeat(default(T), array.Length - index - count), suffix);
Assert.Equal(seed.Take(count), actual);
}
private TSource[] LazyToArray()
{
Debug.Assert(GetCount(onlyIfCheap: true) == -1);
var builder = new LargeArrayBuilder <TSource>(initialize: true);
if (!_appending)
{
builder.SlowAdd(_item);
}
builder.AddRange(_source);
if (_appending)
{
builder.SlowAdd(_item);
}
return(builder.ToArray());
}
public void ToArray_Must_Succeed(int count)
{
// Arrange
var expected = Enumerable
.Range(0, count)
.ToArray();
using var builder = new LargeArrayBuilder <int>(ArrayPool <int> .Shared);
for (var index = 0; index < count; index++)
{
builder.Add(expected[index]);
}
// Act
var result = builder.ToArray();
// Assert
_ = result.Must()
.BeArrayOf <int>()
.BeEqualTo(expected);
}
public void AddCountAndToArray(IEnumerable <T> seed)
{
var builder1 = new LargeArrayBuilder <T>(initialize: true);
var builder2 = new LargeArrayBuilder <T>(initialize: true);
int count = 0;
foreach (T item in seed)
{
count++;
builder1.Add(item);
builder2.SlowAdd(item); // Verify SlowAdd has exactly the same effect as Add.
Assert.Equal(count, builder1.Count);
Assert.Equal(count, builder2.Count);
Assert.Equal(seed.Take(count), builder1.ToArray());
Assert.Equal(seed.Take(count), builder2.ToArray());
}
}
private TSource[] LazyToArray()
{
Debug.Assert(GetCount(onlyIfCheap: true) == -1);
var builder = new LargeArrayBuilder <TSource>(initialize: true);
for (SingleLinkedNode <TSource> node = _prepended; node != null; node = node.Linked)
{
builder.Add(node.Item);
}
builder.AddRange(_source);
if (_appended != null)
{
foreach (TSource item in _appended.ToArray())
{
builder.Add(item);
}
}
return(builder.ToArray());
}
public TSource[] ToArray()
{
using (IEnumerator <TSource> en = _source.GetEnumerator())
{
if (SkipBeforeFirst(en) && en.MoveNext())
{
int remaining = Limit - 1; // Max number of items left, not counting the current element.
int comparand = HasLimit ? 0 : int.MinValue; // If we don't have an upper bound, have the comparison always return true.
int maxCapacity = HasLimit ? Limit : int.MaxValue;
var builder = new LargeArrayBuilder <TSource>(maxCapacity);
do
{
remaining--;
builder.Add(en.Current);
}while (remaining >= comparand && en.MoveNext());
return(builder.ToArray());
}
}
return(Array.Empty <TSource>());
}
