public void InitializeCollection()
{
var list2 = new LocalList <int>(1, 2);
list2.Contains(1).Should().BeTrue();
list2.Contains(2).Should().BeTrue();
list2.Length.Should().Be(2);
var list3 = new LocalList <int>(1, 2, 3);
list3.Contains(1).Should().BeTrue();
list3.Contains(2).Should().BeTrue();
list3.Contains(3).Should().BeTrue();
list3.Length.Should().Be(3);
var list4 = new LocalList <int>(1, 2, 3, 4);
list4.Contains(1).Should().BeTrue();
list4.Contains(2).Should().BeTrue();
list4.Contains(3).Should().BeTrue();
list4.Contains(4).Should().BeTrue();
list4.Length.Should().Be(4);
var list5 = new LocalList <int>(1, 2, 3, 4, 5);
list5.Contains(1).Should().BeTrue();
list5.Contains(2).Should().BeTrue();
list5.Contains(3).Should().BeTrue();
list5.Contains(4).Should().BeTrue();
list5.Contains(5).Should().BeTrue();
list5.Length.Should().Be(5);
}
public void AddRange(LocalList <T> collection)
{
foreach (var element in collection)
{
Add(element);
}
}
public void Join_WithManyInner()
{
var outer = new[] { new Boo {
Id = 1, Int = 1
} };
var inner = new[] { new Foo {
Int = 1
}, new Foo {
Int = 1
}, new Foo {
Int = 1
} };
var joinSum = outer
.Join(inner, o => o.Int, i => i.Int, (o, i) => i.Int)
.Sum();
var outerLocalList = new LocalList <Boo>(outer);
var innerLocalList = new LocalList <Foo>(inner);
var localListSum = outerLocalList
.Join(innerLocalList, o => o.Int, i => i.Int, (o, i) => i.Int)
.Sum(i => i);
Assert.Equal(joinSum, localListSum);
}
public bool MoveNext()
{
if (_position >= _uniqueKeys.Length)
{
return(false);
}
var currentKey = _uniqueKeys.Get(_position);
var groupLocalList = new LocalList <T>();
for (var i = 0; i < _values.Length; i++)
{
var value = _values.Get(i);
if (_comparer.Equals(currentKey, value.Key))
{
groupLocalList.Add(value.Value);
}
}
_current = new LocalGroup(currentKey, groupLocalList);
_position++;
return(true);
}
public void Remove_First(int[] items)
{
var localList = new LocalList <int>(items);
var item = items[0];
Assert.True(localList.Remove(item));
Assert.False(localList.Contains(item));
}
public void Contains <T>(T item)
{
var localList = new LocalList <T>();
localList.Add(item);
Assert.True(localList.Contains(item));
}
public void Contains_WithComparer <T>(T item)
{
var localList = new LocalList <T>();
localList.Add(item);
Assert.True(localList.Contains(item, EqualityComparer <T> .Default));
}
public void AddRange(Boo[] items)
{
var localList = new LocalList <Boo>();
localList.AddRange(new LocalList <Boo>(items));
Assert.Equal(items.Length, localList.Length);
}
public void First_AvoidClosure(int[] items)
{
var localList = new LocalList <int>();
foreach (var item in items)
{
localList.Add(item);
Assert.Equal(item, localList.First((e, i) => e == i, item));
}
}
public void IndexOf(Boo[] items)
{
var localList = new LocalList <Boo>(items);
for (var index = 0; index < items.Length; index++)
{
var boo = items[index];
Assert.Equal(index, localList.IndexOf(boo));
}
}
public void Remove_All(int[] items)
{
var localList = new LocalList <int>(items);
foreach (var item in items)
{
Assert.True(localList.Remove(item));
Assert.False(localList.Contains(item));
}
}
public void Any_AvoidClosure(int[] items)
{
var localList = new LocalList <int>();
foreach (var item in items)
{
localList.Add(item);
Assert.True(localList.Any((e, i) => e == i, item));
}
}
public void First(int[] items)
{
var localList = new LocalList <int>();
foreach (var item in items)
{
localList.Add(item);
// ReSharper disable once HeapView.CanAvoidClosure
Assert.Equal(item, localList.First(e => e == item));
}
}
public void Any(int[] items)
{
var localList = new LocalList <int>();
foreach (var item in items)
{
localList.Add(item);
// ReSharper disable once HeapView.CanAvoidClosure
Assert.True(localList.Any(e => e == item));
}
}
public LocalList <TValue> Select <TValue>(Func <TResult, TValue> selector)
{
var localList = new LocalList <TValue>();
while (MoveNext())
{
localList.Add(selector(_current));
}
return(localList);
}
public TResult[] ToArray()
{
var localList = new LocalList <TResult>();
while (MoveNext())
{
localList.Add(_current);
}
return(localList.ToArray());
}
public void Remove_At(int[] items)
{
var localList = new LocalList <int>(items);
for (var i = 0; i < items.Length; i++)
{
var element = localList[0];
localList.RemoveAt(0);
Assert.False(localList.Contains(element));
}
}
public void Indexer(int count)
{
count = FixCount(count);
var items = Enumerable.Range(0, count).ToArray();
var localList = new LocalList <int>(items);
for (var i = 0; i < localList.Length; i++)
{
Assert.Equal(items[i], localList[i]);
}
}
public LocalList <TResult> Select <TResult>(Selector <TResult> selector)
{
var result = new LocalList <TResult>(_uniqueKeys._length);
while (MoveNext())
{
var element = selector(_current);
result.Add(element);
}
return(result);
}
public LocalList <TResult> OrderBy <TProperty>(Func <TResult, TProperty> path,
Comparer <TProperty> comparer = null)
{
var localList = new LocalList <TResult>();
while (MoveNext())
{
localList.Add(_current);
}
localList.Sort(path, comparer);
return(localList);
}
public LocalList <TValue> OrderBy <TProperty>(Func <TValue, TProperty> path,
Comparer <TProperty> comparer = null)
{
var localList = new LocalList <TValue>();
while (_enumerator.MoveNext())
{
localList.Add(_selector(_enumerator.Current));
}
localList.Sort(path, comparer);
return(localList);
}
public LocalList <TResult> Where <TArg>(Func <TResult, TArg, bool> predicate, TArg arg)
{
var localList = new LocalList <TResult>();
while (MoveNext())
{
if (predicate(_current, arg))
{
localList.Add(_current);
}
}
return(localList);
}
public LocalList <TResult> Where(Predicate <TResult> predicate)
{
var localList = new LocalList <TResult>();
while (MoveNext())
{
if (predicate(_current))
{
localList.Add(_current);
}
}
return(localList);
}
public void GetEnumerator(int[] items)
{
var localList = new LocalList <int>();
foreach (var item in items)
{
localList.Add(item);
}
foreach (var element in localList)
{
Assert.Contains(element, items);
}
}
public void Length(int[] items)
{
var localList = new LocalList <int>();
Assert.Equal(0, localList.Length);
for (var i = 0; i < items.Length; i++)
{
localList.Add(items[i]);
Assert.Equal(i + 1, localList.Length);
}
Assert.Equal(items.Length, localList.Length);
}
public void Clear(int[] items)
{
var localList = new LocalList <int>();
foreach (var item in items)
{
localList.Add(item);
}
localList.Clear();
Assert.True(localList.Length == 0);
Assert.Equal(0, localList.Length);
}
public LocalList <TValue> Where <TArg>(Func <TValue, TArg, bool> predicate, TArg arg)
{
var localList = new LocalList <TValue>();
while (_enumerator.MoveNext())
{
var current = _selector(_enumerator.Current);
if (predicate(current, arg))
{
localList.Add(current);
}
}
return(localList);
}
public T[] ToArray()
{
var localList = new LocalList <T>(_enumerator.Length);
while (_enumerator.MoveNext())
{
var current = _enumerator.Current;
if (_predicate(current))
{
localList.Add(current);
}
}
return(localList.ToArray());
}
public void Add_Many(int count)
{
count = FixCount(count);
var localList = new LocalList <int>();
var items = Enumerable.Range(0, count).ToArray();
foreach (var item in items)
{
localList.Add(item);
Assert.True(localList.Contains(item));
}
Assert.Equal(items.Length, localList.Length);
}
public LocalList <TValue> Select <TValue>(Func <T, TValue> selector)
{
var localList = new LocalList <TValue>();
while (_enumerator.MoveNext())
{
var current = _enumerator.Current;
if (_predicate(current))
{
localList.Add(selector(current));
}
}
return(localList);
}
