Skip to content

Add whitespace handling methods to MemoryExtensions #111439

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

Open
wants to merge 9 commits into
base: main
Choose a base branch
from
Open

Add whitespace handling methods to MemoryExtensions #111439

Show file tree
Hide file tree
Changes from 6 commits
Commits
Show all changes
9 commits
Select commit Hold shift + click to select a range
b35693b
Add whitespace handling methods to MemoryExtensions
AlexRadch Jan 14, 2025
ad80463
Remove unused TestUtilities import in tests
AlexRadch Jan 14, 2025
e4069c1
Tests bugs have been fixed.
AlexRadch Jan 14, 2025
b495165
Apply suggestions from code review
AlexRadch Jan 15, 2025
3f77a0f
Suggestions from code review
AlexRadch Jan 15, 2025
866b91d
Remove unused namespaces in SearchValues.cs
AlexRadch Jan 15, 2025
bb9f9f4
Replaced references to `SearchValues.WhiteSpaces` with
AlexRadch Jan 17, 2025
5b45997
Remove unused using directive in MemoryExtensions
AlexRadch Jan 17, 2025
955d795
Merge branch 'main' into MemoryExtensions.WhiteSpace
jeffhandley Sep 1, 2025
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
5 changes: 5 additions & 0 deletions src/libraries/System.Memory/ref/System.Memory.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -277,6 +277,7 @@ public static partial class MemoryExtensions
public static bool ContainsAnyInRange<T>(this System.ReadOnlySpan<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
[System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
public static bool ContainsAnyInRange<T>(this System.Span<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
public static bool ContainsAnyWhiteSpace(this System.ReadOnlySpan<char> span) { throw null; }
public static void CopyTo<T>(this T[]? source, System.Memory<T> destination) { }
public static void CopyTo<T>(this T[]? source, System.Span<T> destination) { }
[System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
Expand Down Expand Up @@ -331,6 +332,7 @@ public static void CopyTo<T>(this T[]? source, System.Span<T> destination) { }
public static int IndexOfAnyExceptInRange<T>(this System.ReadOnlySpan<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
[System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
public static int IndexOfAnyExceptInRange<T>(this System.Span<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
public static int IndexOfAnyExceptWhiteSpace(this System.ReadOnlySpan<char> span) { throw null; }
public static int IndexOf<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> value) where T : System.IEquatable<T>? { throw null; }
public static int IndexOf<T>(this System.ReadOnlySpan<T> span, T value) where T : System.IEquatable<T>? { throw null; }
[System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
Expand All @@ -340,6 +342,7 @@ public static void CopyTo<T>(this T[]? source, System.Span<T> destination) { }
public static int IndexOfAnyInRange<T>(this System.ReadOnlySpan<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
[System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
public static int IndexOfAnyInRange<T>(this System.Span<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
public static int IndexOfAnyWhiteSpace(this System.ReadOnlySpan<char> span) { throw null; }
public static bool IsWhiteSpace(this System.ReadOnlySpan<char> span) { throw null; }
public static int LastIndexOf(this System.ReadOnlySpan<char> span, System.ReadOnlySpan<char> value, System.StringComparison comparisonType) { throw null; }
public static int LastIndexOfAny<T>(this System.ReadOnlySpan<T> span, System.Buffers.SearchValues<T> values) where T : System.IEquatable<T>? { throw null; }
Expand Down Expand Up @@ -372,6 +375,7 @@ public static void CopyTo<T>(this T[]? source, System.Span<T> destination) { }
public static int LastIndexOfAnyExceptInRange<T>(this System.ReadOnlySpan<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
[System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
public static int LastIndexOfAnyExceptInRange<T>(this System.Span<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
public static int LastIndexOfAnyExceptWhiteSpace(this System.ReadOnlySpan<char> span) { throw null; }
public static int LastIndexOf<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> value) where T : System.IEquatable<T>? { throw null; }
public static int LastIndexOf<T>(this System.ReadOnlySpan<T> span, T value) where T : System.IEquatable<T>? { throw null; }
[System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
Expand All @@ -381,6 +385,7 @@ public static void CopyTo<T>(this T[]? source, System.Span<T> destination) { }
public static int LastIndexOfAnyInRange<T>(this System.ReadOnlySpan<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
[System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
public static int LastIndexOfAnyInRange<T>(this System.Span<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
public static int LastIndexOfAnyWhiteSpace(this System.ReadOnlySpan<char> span) { throw null; }
public static bool Overlaps<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> other) { throw null; }
public static bool Overlaps<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> other, out int elementOffset) { throw null; }
[System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
Expand Down
261 changes: 261 additions & 0 deletions src/libraries/System.Memory/tests/ReadOnlySpan/WhiteSpace.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,261 @@
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.


using System.Collections.Generic;
using System.Runtime.InteropServices;
using Xunit;

namespace System.SpanTests
{
public static partial class ReadOnlySpanTests
{
[Fact]
public static void IsWhiteSpace_True()
{
Assert.True(Span<char>.Empty.IsWhiteSpace());

List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

Assert.True(CollectionsMarshal.AsSpan(chars).IsWhiteSpace());
}

[Fact]
public static void IsWhiteSpace_False()
{
List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

var index = chars.Count;
chars.AddRange(chars.ToArray());
chars.Insert(index, ' ');
var span = CollectionsMarshal.AsSpan(chars);

for (int i = 0; i <= char.MaxValue; i++)
{
if (!char.IsWhiteSpace((char)i))
{
chars[index] = (char)i;
Assert.False(span.IsWhiteSpace());
}
}
}

[Fact]
public static void ContainsAnyWhiteSpace_Found()
{
List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (!char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

var index = chars.Count;
chars.AddRange(chars.ToArray());
chars.Insert(index, ' ');
var span = CollectionsMarshal.AsSpan(chars);

for (int i = 0; i <= char.MaxValue; i++)
{
if (char.IsWhiteSpace((char)i))
{
chars[index] = (char)i;
Assert.True(span.ContainsAnyWhiteSpace());
}
}
}

[Fact]
public static void ContainsAnyWhiteSpace_NotFound()
{
Assert.False(Span<char>.Empty.ContainsAnyWhiteSpace());

List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (!char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

Assert.False(CollectionsMarshal.AsSpan(chars).ContainsAnyWhiteSpace());
}

[Fact]
public static void IndexOfAnyWhiteSpace_Found()
{
List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (!char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

var index = chars.Count;
chars.AddRange(chars.ToArray());
chars.Insert(index, ' ');
chars.Insert(index, ' ');
var span = CollectionsMarshal.AsSpan(chars);

for (int i = 0; i <= char.MaxValue; i++)
{
if (char.IsWhiteSpace((char)i))
{
chars[index] = (char)i;
chars[index + 1] = (char)i;
Assert.Equal(index, span.IndexOfAnyWhiteSpace());
}
}
}

[Fact]
public static void IndexOfAnyWhiteSpace_NotFound()
{
Assert.Equal(-1, Span<char>.Empty.IndexOfAnyWhiteSpace());

List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (!char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

Assert.Equal(-1, CollectionsMarshal.AsSpan(chars).IndexOfAnyWhiteSpace());
}

[Fact]
public static void IndexOfAnyExceptWhiteSpace_Found()
{
List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

var index = chars.Count;
chars.AddRange(chars.ToArray());
chars.Insert(index, ' ');
chars.Insert(index, ' ');
var span = CollectionsMarshal.AsSpan(chars);

for (int i = 0; i <= char.MaxValue; i++)
{
if (!char.IsWhiteSpace((char)i))
{
chars[index] = (char)i;
chars[index + 1] = (char)i;
Assert.Equal(index, span.IndexOfAnyExceptWhiteSpace());
}
}
}

[Fact]
public static void IndexOfAnyExceptWhiteSpace_NotFound()
{
Assert.Equal(-1, Span<char>.Empty.IndexOfAnyExceptWhiteSpace());

List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

Assert.Equal(-1, CollectionsMarshal.AsSpan(chars).IndexOfAnyExceptWhiteSpace());
}

[Fact]
public static void LastIndexOfAnyWhiteSpace_Found()
{
List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (!char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

var index = chars.Count;
chars.AddRange(chars.ToArray());
chars.Insert(index, ' ');
chars.Insert(index, ' ');
var span = CollectionsMarshal.AsSpan(chars);

for (int i = 0; i <= char.MaxValue; i++)
{
if (char.IsWhiteSpace((char)i))
{
chars[index] = (char)i;
chars[index + 1] = (char)i;
Assert.Equal(index + 1, span.LastIndexOfAnyWhiteSpace());
}
}
}

[Fact]
public static void LastIndexOfAnyWhiteSpace_NotFound()
{
Assert.Equal(-1, Span<char>.Empty.LastIndexOfAnyWhiteSpace());

List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (!char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

Assert.Equal(-1, CollectionsMarshal.AsSpan(chars).LastIndexOfAnyWhiteSpace());
}

[Fact]
public static void LastIndexOfAnyExceptWhiteSpace_Found()
{
List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

var index = chars.Count;
chars.AddRange(chars.ToArray());
chars.Insert(index, ' ');
chars.Insert(index, ' ');
var span = CollectionsMarshal.AsSpan(chars);

for (int i = 0; i <= char.MaxValue; i++)
{
if (!char.IsWhiteSpace((char)i))
{
chars[index] = (char)i;
chars[index + 1] = (char)i;
Assert.Equal(index + 1, span.LastIndexOfAnyExceptWhiteSpace());
}
}
}

[Fact]
public static void LastIndexOfAnyExceptWhiteSpace_NotFound()
{
Assert.Equal(-1, Span<char>.Empty.LastIndexOfAnyExceptWhiteSpace());

List<char> chars = [];
for (int i = 0; i <= char.MaxValue; i++)
{
if (char.IsWhiteSpace((char)i))
chars.Add((char)i);
}

Assert.Equal(-1, CollectionsMarshal.AsSpan(chars).LastIndexOfAnyExceptWhiteSpace());
}
}
}
1 change: 1 addition & 0 deletions src/libraries/System.Memory/tests/System.Memory.Tests.csproj
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -193,6 +193,7 @@
<Compile Include="ReadOnlySpan\ToArray.cs" />
<Compile Include="ReadOnlySpan\ToString.cs" />
<Compile Include="ReadOnlySpan\ToUpperLower.cs" />
<Compile Include="ReadOnlySpan\WhiteSpace.cs" />
</ItemGroup>
<ItemGroup>
<Compile Include="Memory\AsMemory.cs" />
Expand Down
Loading
Loading