Skip to content

Commit ad4c329

Browse files
GuiorgyGuiorgy
committed
added tests for ReadOnlySpan.SplitAny
1 parent dffb659 commit ad4c329

File tree

3 files changed

+282
-0
lines changed

3 files changed

+282
-0
lines changed

‎tests/ReadOnlySpanTests.cs‎

Lines changed: 206 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -191,6 +191,179 @@ static void AssertOptions(StringSplitOptions options)
191191
AssertOptions(options);
192192
}
193193
}
194+
195+
[Fact]
196+
public void TestSplitAny()
197+
{
198+
int[] integerArray = GenerateRandomIntegers(count, minValue, maxValue).ToArray();
199+
ReadOnlySpan<int> integerSpan = integerArray;
200+
201+
// source contains delimiter
202+
int[] integerDelimiters = Enumerable.Range(0, 5).Select(_ => integerArray[random.Next(integerArray.Length)]).ToArray();
203+
AssertMethodResults(
204+
expected: SplitAny(integerArray, integerDelimiters),
205+
actual: integerSpan.SplitAny(integerDelimiters).ToSystemEnumerable(),
206+
source: integerArray,
207+
method: nameof(ReadOnlySpanExtensions.SplitAny),
208+
args: ("delimiters", integerDelimiters)
209+
);
210+
211+
// source does not contain delimiter
212+
integerDelimiters = Enumerable.Range(0, 5).Select(i => maxValue + i).ToArray();
213+
AssertMethodResults(
214+
expected: SplitAny(integerArray, integerDelimiters),
215+
actual: integerSpan.SplitAny(integerDelimiters).ToSystemEnumerable(),
216+
source: integerArray,
217+
method: nameof(ReadOnlySpanExtensions.SplitAny),
218+
args: ("delimiters", integerDelimiters)
219+
);
220+
221+
char[] charArray = GenerateRandomString(length).ToCharArray();
222+
ReadOnlySpan<char> charSpan = charArray;
223+
224+
// source contains delimiter
225+
char[] charDelimiters = Enumerable.Range(0, 5).Select(_ => charArray[random.Next(charArray.Length)]).ToArray();
226+
AssertMethodResults(
227+
expected: SplitAny(charArray, charDelimiters),
228+
actual: charSpan.SplitAny(charDelimiters).ToSystemEnumerable(),
229+
source: charArray,
230+
method: nameof(ReadOnlySpanExtensions.SplitAny),
231+
args: ("delimiters", charDelimiters)
232+
);
233+
234+
// source does not contain delimiter
235+
charDelimiters = Enumerable.Range(0, 5).Select(_ => '!').ToArray(); // the generated array only consists of lowercase letters and numbers
236+
AssertMethodResults(
237+
expected: SplitAny(charArray, charDelimiters),
238+
actual: charSpan.SplitAny(charDelimiters).ToSystemEnumerable(),
239+
source: charArray,
240+
method: nameof(ReadOnlySpanExtensions.SplitAny),
241+
args: ("delimiters", charDelimiters)
242+
);
243+
}
244+
245+
[Fact]
246+
public void TestSplitAnyWithCount()
247+
{
248+
int[] integerArray = GenerateRandomIntegers(count, minValue, maxValue).ToArray();
249+
ReadOnlySpan<int> integerSpan = integerArray;
250+
251+
// source contains delimiter
252+
int[] integerDelimiters = Enumerable.Range(0, 5).Select(_ => integerArray[random.Next(integerArray.Length)]).ToArray();
253+
int countDelimiters = integerSpan.Count(integerDelimiters);
254+
AssertMethodResults(
255+
expected: SplitAny(integerArray, integerDelimiters, countDelimiters),
256+
actual: integerSpan.SplitAny(integerDelimiters, countDelimiters).ToSystemEnumerable(),
257+
source: integerArray,
258+
method: nameof(ReadOnlySpanExtensions.SplitAny),
259+
args: [("delimiters", integerDelimiters), ("count", countDelimiters)]
260+
);
261+
262+
// source does not contain delimiter
263+
integerDelimiters = Enumerable.Range(0, 5).Select(i => maxValue + i).ToArray();
264+
AssertMethodResults(
265+
expected: SplitAny(integerArray, integerDelimiters, countDelimiters),
266+
actual: integerSpan.SplitAny(integerDelimiters, countDelimiters).ToSystemEnumerable(),
267+
source: integerArray,
268+
method: nameof(ReadOnlySpanExtensions.SplitAny),
269+
args: [("delimiters", integerDelimiters), ("count", countDelimiters)]
270+
);
271+
272+
char[] charArray = GenerateRandomString(length).ToCharArray();
273+
ReadOnlySpan<char> charSpan = charArray;
274+
275+
// source contains delimiter
276+
char[] charDelimiters = Enumerable.Range(0, 5).Select(_ => charArray[random.Next(charArray.Length)]).ToArray();
277+
countDelimiters = charSpan.Count(charDelimiters);
278+
AssertMethodResults(
279+
expected: SplitAny(charArray, charDelimiters, countDelimiters),
280+
actual: charSpan.SplitAny(charDelimiters, countDelimiters).ToSystemEnumerable(),
281+
source: charArray,
282+
method: nameof(ReadOnlySpanExtensions.SplitAny),
283+
args: [("delimiters", charDelimiters), ("count", countDelimiters)]
284+
);
285+
286+
// source does not contain delimiter
287+
charDelimiters = Enumerable.Range(0, 5).Select(_ => '!').ToArray(); // the generated array only consists of lowercase letters and numbers
288+
AssertMethodResults(
289+
expected: SplitAny(charArray, charDelimiters, countDelimiters),
290+
actual: charSpan.SplitAny(charDelimiters, countDelimiters).ToSystemEnumerable(),
291+
source: charArray,
292+
method: nameof(ReadOnlySpanExtensions.SplitAny),
293+
args: [("delimiters", charDelimiters), ("count", countDelimiters)]
294+
);
295+
}
296+
297+
[Fact]
298+
public void TestSplitAnyString()
299+
{
300+
static void AssertOptions(StringSplitOptions options)
301+
{
302+
string @string = GenerateRandomString(length);
303+
ReadOnlySpan<char> charSpan = @string;
304+
305+
// source contains delimiter
306+
char[] charDelimiters = Enumerable.Range(0, 5).Select(_ => @string[random.Next(@string.Length)]).ToArray();
307+
AssertMethodResults(
308+
expected: @string.Split(charDelimiters, options),
309+
actual: charSpan.SplitAny(charDelimiters, options).ToSystemEnumerable(),
310+
source: @string,
311+
method: nameof(ReadOnlySpanExtensions.SplitAny),
312+
args: [("delimiters", charDelimiters), ("options", options)]
313+
);
314+
315+
// source does not contain delimiter
316+
charDelimiters = Enumerable.Range(0, 5).Select(_ => '!').ToArray(); // the generated array only consists of lowercase letters and numbers
317+
AssertMethodResults(
318+
expected: @string.Split(charDelimiters, options),
319+
actual: charSpan.SplitAny(charDelimiters, options).ToSystemEnumerable(),
320+
source: @string,
321+
method: nameof(ReadOnlySpanExtensions.SplitAny),
322+
args: [("delimiters", charDelimiters), ("options", options)]
323+
);
324+
}
325+
326+
foreach(StringSplitOptions _options in stringSplitOptions)
327+
{
328+
AssertOptions(_options);
329+
}
330+
}
331+
332+
[Fact]
333+
public void TestSplitAnyStringWithCount()
334+
{
335+
static void AssertOptions(StringSplitOptions options)
336+
{
337+
string @string = GenerateRandomString(length);
338+
ReadOnlySpan<char> charSpan = @string;
339+
340+
// source contains delimiter
341+
char[] charDelimiters = Enumerable.Range(0, 5).Select(_ => @string[random.Next(@string.Length)]).ToArray();
342+
int countDelimiters = charSpan.Count(charDelimiters);
343+
AssertMethodResults(
344+
expected: @string.Split(charDelimiters, countDelimiters, options),
345+
actual: charSpan.SplitAny(charDelimiters, options, countDelimiters).ToSystemEnumerable(),
346+
source: @string,
347+
method: nameof(ReadOnlySpanExtensions.SplitAny),
348+
args: [("delimiters", charDelimiters), ("options", options), ("count", countDelimiters)]
349+
);
350+
351+
// source does not contain delimiter
352+
charDelimiters = Enumerable.Range(0, 5).Select(_ => '!').ToArray(); // the generated array only consists of lowercase letters and numbers
353+
AssertMethodResults(
354+
expected: @string.Split(charDelimiters, countDelimiters, options),
355+
actual: charSpan.SplitAny(charDelimiters, options, countDelimiters).ToSystemEnumerable(),
356+
source: @string,
357+
method: nameof(ReadOnlySpanExtensions.SplitAny),
358+
args: [("delimiters", charDelimiters), ("options", options), ("count", countDelimiters)]
359+
);
360+
}
361+
362+
foreach(StringSplitOptions _options in stringSplitOptions)
363+
{
364+
AssertOptions(_options);
365+
}
366+
}
194367
}
195368

196369
public static class Facts
@@ -229,6 +402,39 @@ public void DelimiterAtTheEndResultInEmptySpan()
229402
);
230403
}
231404
}
405+
406+
public sealed class SplitAny
407+
{
408+
[Fact]
409+
public void ConsecutiveDelimitersResultInEmptySpan()
410+
{
411+
const string charArray = "abca";
412+
ReadOnlySpan<char> charSpan = charArray;
413+
char[] charDelimiters = ['b', 'c'];
414+
AssertMethodResults(
415+
expected: SplitAny(charArray, charDelimiters),
416+
actual: charSpan.SplitAny(charDelimiters).ToSystemEnumerable(),
417+
source: charArray,
418+
method: nameof(ReadOnlySpanExtensions.SplitAny),
419+
args: ("delimiters", charDelimiters)
420+
);
421+
}
422+
423+
[Fact]
424+
public void DelimiterAtTheEndResultInEmptySpan()
425+
{
426+
const string charArray = "aac";
427+
ReadOnlySpan<char> charSpan = charArray;
428+
char[] charDelimiters = ['b', 'c'];
429+
AssertMethodResults(
430+
expected: SplitAny(charArray, charDelimiters),
431+
actual: charSpan.SplitAny(charDelimiters).ToSystemEnumerable(),
432+
source: charArray,
433+
method: nameof(ReadOnlySpanExtensions.SplitAny),
434+
args: ("delimiters", charDelimiters)
435+
);
436+
}
437+
}
232438
}
233439
}
234440

‎tests/TestHelper.cs‎

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -202,6 +202,34 @@ public static int Count<T>(this Span<T> span, T value) where T : IEquatable<T>
202202
}
203203
#endif
204204

205+
/// <summary>Counts the number of times any of the specified <paramref name="values"/> occur in the <paramref name="span"/>.</summary>
206+
/// <typeparam name="T">The element type of the span.</typeparam>
207+
/// <param name="span">The span to search.</param>
208+
/// <param name="values">The values for which to search.</param>
209+
/// <returns>The number of times any of the <paramref name="values"/> was found in the <paramref name="span"/>.</returns>
210+
public static int Count<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> values) where T : IEquatable<T>
211+
{
212+
int count = 0;
213+
foreach(T item in span)
214+
{
215+
if(values.Contains(item))
216+
{
217+
count++;
218+
}
219+
}
220+
return count;
221+
}
222+
223+
/// <summary>Counts the number of times any of the specified <paramref name="values"/> occur in the <paramref name="span"/>.</summary>
224+
/// <typeparam name="T">The element type of the span.</typeparam>
225+
/// <param name="span">The span to search.</param>
226+
/// <param name="values">The values for which to search.</param>
227+
/// <returns>The number of times any of the <paramref name="values"/> was found in the <paramref name="span"/>.</returns>
228+
public static int Count<T>(this Span<T> span, ReadOnlySpan<T> values) where T : IEquatable<T>
229+
{
230+
return Count((ReadOnlySpan<T>)span, values);
231+
}
232+
205233
/// <summary>
206234
/// Splits a sequence into a maximum number of subsequences based on a specified delimiter.
207235
/// </summary>

‎tests/ToSystemEnumerableExtensions.cs‎

Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -55,5 +55,53 @@ public static IEnumerable<IEnumerable<char>> ToSystemEnumerable(this SpanSplitSt
5555

5656
return list;
5757
}
58+
59+
public static IEnumerable<IEnumerable<T>> ToSystemEnumerable<T>(this SpanSplitAnyEnumerator<T> spanEnumerator) where T : IEquatable<T>
60+
{
61+
List<T[]> list = [];
62+
63+
foreach(ReadOnlySpan<T> element in spanEnumerator)
64+
{
65+
list.Add(element.ToArray());
66+
}
67+
68+
return list;
69+
}
70+
71+
public static IEnumerable<IEnumerable<T>> ToSystemEnumerable<T>(this SpanSplitAnyWithCountEnumerator<T> spanEnumerator) where T : IEquatable<T>
72+
{
73+
List<T[]> list = [];
74+
75+
foreach(ReadOnlySpan<T> element in spanEnumerator)
76+
{
77+
list.Add(element.ToArray());
78+
}
79+
80+
return list;
81+
}
82+
83+
public static IEnumerable<IEnumerable<char>> ToSystemEnumerable(this SpanSplitAnyStringSplitOptionsEnumerator spanEnumerator)
84+
{
85+
List<char[]> list = [];
86+
87+
foreach(ReadOnlySpan<char> element in spanEnumerator)
88+
{
89+
list.Add(element.ToArray());
90+
}
91+
92+
return list;
93+
}
94+
95+
public static IEnumerable<IEnumerable<char>> ToSystemEnumerable(this SpanSplitAnyStringSplitOptionsWithCountEnumerator spanEnumerator)
96+
{
97+
List<char[]> list = [];
98+
99+
foreach(ReadOnlySpan<char> element in spanEnumerator)
100+
{
101+
list.Add(element.ToArray());
102+
}
103+
104+
return list;
105+
}
58106
}
59107
}

0 commit comments

Comments
 (0)