Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Replace: IList<> implementation #454

Merged
merged 3 commits into from
May 24, 2023
Merged

Replace: IList<> implementation #454

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
8dfe708
`Replace`: `IList<>` implementation
viceroypenguin May 23, 2023
1df8231
Force testing both `GetEnumerable` and `CopyTo`
viceroypenguin May 24, 2023
01e5441
Fix bug in index selection of `CopyTo`
viceroypenguin May 24, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
51 changes: 50 additions & 1 deletion Source/SuperLinq/Replace.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -24,6 +24,9 @@ public static IEnumerable<TSource> Replace<TSource>(
{
Guard.IsNotNull(source);

if (source is IList<TSource> list)
return new ReplaceIterator<TSource>(list, value, index);

return Core(source, index, value);

static IEnumerable<TSource> Core(
Expand Down Expand Up @@ -59,6 +62,9 @@ public static IEnumerable<TSource> Replace<TSource>(
{
Guard.IsNotNull(source);

if (source is IList<TSource> list)
return new ReplaceIterator<TSource>(list, value, index);

return Core(source, value, index);

static IEnumerable<TSource> Core(IEnumerable<TSource> source, TSource value, Index index)
Expand All @@ -78,7 +84,7 @@ static IEnumerable<TSource> Core(IEnumerable<TSource> source, TSource value, Ind
}
else
{
var cnt = index.Value + 1;
var cnt = index.Value;
var queue = new Queue<TSource>();

foreach (var e in source)
Expand All @@ -102,4 +108,47 @@ static IEnumerable<TSource> Core(IEnumerable<TSource> source, TSource value, Ind
}
}
}

private sealed class ReplaceIterator<TSource> : ListIterator<TSource>
{
private readonly IList<TSource> _source;
private readonly TSource _value;
private readonly Index _index;

public ReplaceIterator(IList<TSource> source, TSource value, Index index)
{
_source = source;
_value = value;
_index = index;
}

public override int Count => _source.Count;

protected override IEnumerable<TSource> GetEnumerable()
{
var cnt = (uint)_source.Count;
var idx = _index.GetOffset(_source.Count);

for (var i = 0; i < cnt; i++)
yield return i == idx ? _value : _source[i];
}

public override void CopyTo(TSource[] array, int arrayIndex)
{
_source.CopyTo(array, arrayIndex);

var idx = _index.GetOffset(_source.Count);
if (idx >= 0 && idx < _source.Count)
array[arrayIndex + idx] = _value;
}

protected override TSource ElementAt(int index)
{
Guard.IsBetweenOrEqualTo(index, 0, Count - 1);

return index == _index.GetOffset(_source.Count)
? _value
: _source[index];
}
}
}
136 changes: 84 additions & 52 deletions Tests/SuperLinq.Test/ReplaceTest.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -23,81 +23,113 @@ public void ReplaceEmptySequence()
}

public static IEnumerable<object[]> Indices() =>
Enumerable.Range(0, 10).Select(i => new object[] { i, });
Enumerable.Range(0, 10)
.SelectMany(
_ => Enumerable.Range(1, 10).GetAllSequences(),
(i, s) => new object[] { i, s, });

[Theory, MemberData(nameof(Indices))]
public void ReplaceIntIndex(int index)
public void ReplaceIntIndex(int index, IDisposableEnumerable<int> seq)
{
using var seq = Enumerable.Range(1, 10).AsTestingSequence();

var result = seq.Replace(index, 30);
result.AssertSequenceEqual(
Enumerable.Range(1, index)
.Append(30)
.Concat(Enumerable.Range(index + 2, 9 - index)));
using (seq)
{
var result = seq.Replace(index, 30);
result.AssertSequenceEqual(
Enumerable.Range(1, index)
.Append(30)
.Concat(Enumerable.Range(index + 2, 9 - index)),
testCollectionEnumerable: true);
}
}

[Theory, MemberData(nameof(Indices))]
public void ReplaceStartIndex(int index)
public void ReplaceStartIndex(int index, IDisposableEnumerable<int> seq)
{
using var seq = Enumerable.Range(1, 10).AsTestingSequence();

var result = seq.Replace(new Index(index), 30);
result.AssertSequenceEqual(
Enumerable.Range(1, index)
.Append(30)
.Concat(Enumerable.Range(index + 2, 9 - index)));
using (seq)
{
var result = seq.Replace(new Index(index), 30);
result.AssertSequenceEqual(
Enumerable.Range(1, index)
.Append(30)
.Concat(Enumerable.Range(index + 2, 9 - index)),
testCollectionEnumerable: true);
}
}

[Theory, MemberData(nameof(Indices))]
public void ReplaceEndIndex(int index)
public void ReplaceEndIndex(int index, IDisposableEnumerable<int> seq)
{
using var seq = Enumerable.Range(1, 10).AsTestingSequence();

var result = seq.Replace(^index, 30);
result.AssertSequenceEqual(
Enumerable.Range(1, 9 - index)
.Append(30)
.Concat(Enumerable.Range(11 - index, index)));
using (seq)
{
// offset by one because 0..9 is less useful than 1..10
var result = seq.Replace(^(index + 1), 30);
result.AssertSequenceEqual(
Enumerable.Range(1, 9 - index)
.Append(30)
.Concat(Enumerable.Range(11 - index, index)),
testCollectionEnumerable: true);
}
}

[Theory, MemberData(nameof(Indices))]
public void ReplaceEndIndexWithCollection(int index)
{
var seq = Enumerable.Range(1, 10).ToArray();
public static IEnumerable<object[]> GetSequences() =>
Enumerable.Range(1, 10)
.GetListSequences()
.Select(x => new object[] { x });

// offset by one because 0..9 is less useful than 1..10
var result = seq.Replace(^(index + 1), 30);
result.AssertSequenceEqual(
Enumerable.Range(1, 9 - index)
.Append(30)
.Concat(Enumerable.Range(11 - index, index)));
[Theory]
[MemberData(nameof(GetSequences))]
public void ReplaceIntIndexPastSequenceLength(IDisposableEnumerable<int> seq)
{
using (seq)
{
var result = seq.Replace(10, 30);
result.AssertSequenceEqual(
Enumerable.Range(1, 10),
testCollectionEnumerable: true);
}
}

[Fact]
public void ReplaceIntIndexPastSequenceLength()
[Theory]
[MemberData(nameof(GetSequences))]
public void ReplaceStartIndexPastSequenceLength(IDisposableEnumerable<int> seq)
{
using var seq = Enumerable.Range(1, 10).AsTestingSequence();

var result = seq.Replace(10, 30);
result.AssertSequenceEqual(Enumerable.Range(1, 10));
using (seq)
{
var result = seq.Replace(new Index(10), 30);
result.AssertSequenceEqual(
Enumerable.Range(1, 10),
testCollectionEnumerable: true);
}
}

[Fact]
public void ReplaceStartIndexPastSequenceLength()
[Theory]
[MemberData(nameof(GetSequences))]
public void ReplaceEndIndexPastSequenceLength(IDisposableEnumerable<int> seq)
{
using var seq = Enumerable.Range(1, 10).AsTestingSequence();

var result = seq.Replace(new Index(10), 30);
result.AssertSequenceEqual(Enumerable.Range(1, 10));
using (seq)
{
var result = seq.Replace(^11, 30);
result.AssertSequenceEqual(
Enumerable.Range(1, 10),
testCollectionEnumerable: true);
}
}

[Fact]
public void ReplaceEndIndexPastSequenceLength()
public void ReplaceListBehavior()
{
using var seq = Enumerable.Range(1, 10).AsTestingSequence();

var result = seq.Replace(^10, 30);
result.AssertSequenceEqual(Enumerable.Range(1, 10));
using var seq = Enumerable.Range(0, 10_000).AsBreakingList();

var result = seq.Replace(20, -1);
Assert.Equal(10_000, result.Count());
Assert.Equal(10, result.ElementAt(10));
Assert.Equal(-1, result.ElementAt(20));
Assert.Equal(9_950, result.ElementAt(^50));

result.ToList()
.AssertSequenceEqual(
Enumerable.Range(0, 20)
.Append(-1)
.Concat(Enumerable.Range(21, 9_979)));
}
}
9 changes: 6 additions & 3 deletions Tests/SuperLinq.Test/TestExtensions.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -20,8 +20,8 @@ public static IEnumerable<int> SeqExceptionAt(int index) =>
/// <summary>
/// Just to make our testing easier so we can chain the assertion call.
/// </summary>
internal static void AssertSequenceEqual<T>(this IEnumerable<T> actual, IEnumerable<T> expected) =>
actual.AssertSequenceEqual(expected as IList<T> ?? expected.ToList());
internal static void AssertSequenceEqual<T>(this IEnumerable<T> actual, IEnumerable<T> expected, bool testCollectionEnumerable = false) =>
actual.AssertSequenceEqual(expected as IList<T> ?? expected.ToList(), testCollectionEnumerable);

/// <summary>
/// Make testing even easier - a params array makes for readable tests :)
Expand All @@ -30,14 +30,17 @@ internal static void AssertSequenceEqual<T>(this IEnumerable<T> actual, IEnumera
internal static void AssertSequenceEqual<T>(this IEnumerable<T> actual, params T[] expected) =>
actual.AssertSequenceEqual((IList<T>)expected);

internal static void AssertSequenceEqual<T>(this IEnumerable<T> actual, IList<T> expected)
internal static void AssertSequenceEqual<T>(this IEnumerable<T> actual, IList<T> expected, bool testCollectionEnumerable = false)
{
if (actual is ICollection<T>)
{
var arr = new T[expected.Count];
var cnt = SuperEnumerable.CopyTo(actual, arr);
Assert.Equal(expected.Count, cnt);
Assert.Equal(expected, arr);

if (testCollectionEnumerable)
Assert.Equal(expected, actual);
}
else
{
Expand Down