Skip to content

Commit 3f9525a

Browse files
dragon7307dragon7307
committed
finished refactoring tests to comply with project's style-guidelines.
1 parent ade52cb commit 3f9525a

File tree

7 files changed

+372
-362
lines changed

7 files changed

+372
-362
lines changed

‎tests/unit-tests/Tests/ReadOnlySpan/Split/SplitAny_StringSplitOptions/Data.cs‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,8 @@ public sealed partial class SplitAny_StringSplitOptions
88
{
99
public static TheoryData<StringSplitOptions> StringSplitOptionsWithRemoveEmptyEntries
1010
=> (TheoryData<StringSplitOptions>)stringSplitOptions.Where(x => x.HasFlag(StringSplitOptions.RemoveEmptyEntries));
11+
public static TheoryData<StringSplitOptions> StringSplitOptionsWithoutRemoveEmptyEntries
12+
=> (TheoryData<StringSplitOptions>)stringSplitOptions.Where(x => !x.HasFlag(StringSplitOptions.RemoveEmptyEntries));
1113
public static TheoryData<StringSplitOptions> StringSplitOptions_Data
1214
=> (TheoryData<StringSplitOptions>)stringSplitOptions;
1315
public static TheoryData<char[][], string, int, char[]> CountEqualDelimiterCountResultsInSpanWithEverythingAfterAndIncludingLastDelimiter_Data

‎tests/unit-tests/Tests/ReadOnlySpan/Split/SplitAny_StringSplitOptions/Tests.cs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@ public static partial class ReadOnlySpanSplitTests
77
public sealed partial class SplitAny_StringSplitOptions
88
{
99
[Theory]
10-
[MemberData(nameof(StringSplitOptionsWithRemoveEmptyEntries))]
10+
[MemberData(nameof(StringSplitOptionsWithoutRemoveEmptyEntries))]
1111
public void EmptySourceResultInEmptySpanUnless_StringSplitOptions_RemoveEmptyEntries_IsSet(StringSplitOptions options)
1212
{
1313
ReadOnlySpan<char> emptySpan = "";

‎tests/unit-tests/Tests/ReadOnlySpan/Split/SplitSequence_StringSplitOptions/Data.cs‎

Lines changed: 45 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,45 @@
1+
namespace SpanExtensions.Tests.UnitTests
2+
{
3+
public static partial class ReadOnlySpanSplitTests
4+
{
5+
public sealed partial class SplitStringSequence
6+
{
7+
public static TheoryData<StringSplitOptions> StringSplitOptionsWithRemoveEmptyEntries
8+
=> (TheoryData<StringSplitOptions>)stringSplitOptions.Where(x => x.HasFlag(StringSplitOptions.RemoveEmptyEntries));
9+
public static TheoryData<StringSplitOptions> StringSplitOptionsWithoutRemoveEmptyEntries
10+
=> (TheoryData<StringSplitOptions>)stringSplitOptions.Where(x => !x.HasFlag(StringSplitOptions.RemoveEmptyEntries));
11+
public static TheoryData<StringSplitOptions> StringSplitOptions_Data
12+
=> (TheoryData<StringSplitOptions>)stringSplitOptions;
13+
public static TheoryData<StringSplitOptions, CountExceedingBehaviour, char[]> CountEqualZeroResultsInNothing_Data
14+
=> new TheoryData<StringSplitOptions, CountExceedingBehaviour, char[]>
15+
{
16+
{ StringSplitOptions.None, CountExceedingBehaviour.CutRemainingElements, ['a', 'b'] },
17+
{ StringSplitOptions.RemoveEmptyEntries, CountExceedingBehaviour.CutRemainingElements, ['a', 'b'] },
18+
{ StringSplitOptions.TrimEntries, CountExceedingBehaviour.CutRemainingElements, ['a', 'b'] },
19+
{ StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries, CountExceedingBehaviour.CutRemainingElements , ['a', 'b'] },
20+
{ StringSplitOptions.None, CountExceedingBehaviour.AppendRemainingElements, ['a', 'b'] },
21+
{ StringSplitOptions.RemoveEmptyEntries, CountExceedingBehaviour.AppendRemainingElements, ['a', 'b'] },
22+
{ StringSplitOptions.TrimEntries, CountExceedingBehaviour.AppendRemainingElements, ['a', 'b'] },
23+
{ StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries, CountExceedingBehaviour.AppendRemainingElements, ['a', 'b'] },
24+
};
25+
public static TheoryData<char[][], string, int, char[]> CountEqualDelimiterCountResultsInSpanWithEverythingAfterAndIncludingLastDelimiter_Data
26+
=> new TheoryData<char[][], string, int, char[]>
27+
{
28+
{ new char[][] { ['a', 'a', 'b', 'c', 'a', 'a'] }, "aabcaa", 1, ['b', 'c'] },
29+
{ new char[][] { ['a', 'a'], ['a', 'a', 'b', 'c', 'a', 'a'] }, "aabcaabcaa", 2, ['b', 'c'] }
30+
};
31+
public static TheoryData<char[][], string, int, char[]> DelimiterAtTheEndWithCountEqualDelimiterCountResultsInSpanWithDelimiter_Data
32+
=> new TheoryData<char[][], string, int, char[]>
33+
{
34+
{ new char[][] { ['a', 'a', 'b', 'c'] }, "aabc", 1, ['b', 'c'] },
35+
{ new char[][] { ['a', 'a'], ['a', 'b', 'c'] }, "aabcabc", 2, ['b', 'c'] }
36+
};
37+
public static TheoryData<char[][], string, int, char[]> CountEqualDelimiterCountResultsInEverythingAfterAndIncludingLastDelimiterBeingCut_Data
38+
=> new TheoryData<char[][], string, int, char[]>
39+
{
40+
{ new char[][] { ['a', 'a'] }, "aabaa", 1, ['b', 'c'] },
41+
{ new char[][] { ['a', 'a'], ['a', 'a'] }, "aabaabcaa", 2, ['b', 'c'] }
42+
};
43+
}
44+
}
45+
}

‎tests/unit-tests/Tests/ReadOnlySpan/Split/SplitSequence_StringSplitOptions/Tests.cs‎

Lines changed: 320 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,320 @@
1+
using static SpanExtensions.Tests.UnitTests.TestHelper;
2+
3+
namespace SpanExtensions.Tests.UnitTests
4+
{
5+
public static partial class ReadOnlySpanSplitTests
6+
{
7+
public sealed partial class SplitStringSequence
8+
{
9+
[Theory]
10+
[MemberData(nameof(StringSplitOptionsWithoutRemoveEmptyEntries))]
11+
public void EmptySourceResultInEmptySpan(StringSplitOptions options)
12+
{
13+
ReadOnlySpan<char> emptySpan = "";
14+
15+
var expected = EmptyNestedCharArray;
16+
17+
var actual = emptySpan.Split(['b', 'c'], options).ToSystemEnumerable();
18+
19+
AssertEqual(expected, actual);
20+
}
21+
22+
[Theory]
23+
[MemberData(nameof(StringSplitOptions_Data))]
24+
public void NoDelimiterOccurenceResultsInNoChange(StringSplitOptions options)
25+
{
26+
ReadOnlySpan<char> source = ABBAArray;
27+
28+
var expected = NestedABBAArray;
29+
30+
var actual = source.Split(['c', 'd'], options).ToSystemEnumerable();
31+
32+
AssertEqual(expected, actual);
33+
}
34+
35+
[Fact]
36+
public void EmptyDelimiterSpanResultsInNoChange()
37+
{
38+
ReadOnlySpan<char> source = ABBAArray;
39+
40+
var expected = NestedABBAArray;
41+
42+
var actual = source.Split([], StringSplitOptions.None).ToSystemEnumerable();
43+
44+
AssertEqual(expected, actual);
45+
}
46+
47+
[Theory]
48+
[MemberData(nameof(CountEqualZeroResultsInNothing_Data))]
49+
public void CountEqualZeroResultsInNothing(StringSplitOptions options, CountExceedingBehaviour countExceedingBehaviour, char[] delimiter)
50+
{
51+
ReadOnlySpan<char> source = ABBAArray;
52+
53+
var expected = EmptyNestedCharArray;
54+
55+
var actual = source.Split(delimiter, 0, options, countExceedingBehaviour).ToSystemEnumerable();
56+
57+
AssertEqual(expected, actual);
58+
}
59+
60+
[Fact]
61+
public void CountEqualOneResultsInNoChange()
62+
{
63+
ReadOnlySpan<char> source = ABBAArray;
64+
65+
var expected = NestedABBAArray;
66+
67+
var actual = source.Split(['a', 'b'], 1, StringSplitOptions.None).ToSystemEnumerable();
68+
69+
AssertEqual(expected, actual);
70+
}
71+
72+
[Fact]
73+
public void ConsecutiveDelimitersResultInEmptySpan()
74+
{
75+
ReadOnlySpan<char> source = "abcbca";
76+
77+
char[][] expected = [['a'], [], ['a']];
78+
79+
var actual = source.Split(['b', 'c'], StringSplitOptions.None).ToSystemEnumerable();
80+
81+
AssertEqual(expected, actual);
82+
}
83+
84+
[Theory]
85+
[MemberData(nameof(StringSplitOptionsWithRemoveEmptyEntries))]
86+
public void ConsecutiveDelimitersWithRemoveEmptyEntriesOptionResultInNoEmptySpan(StringSplitOptions options)
87+
{
88+
ReadOnlySpan<char> source = "abcbca";
89+
90+
char[][] expected = [['a'], [], ['a']];
91+
92+
var actual = source.Split(['b', 'c'], options).ToSystemEnumerable();
93+
94+
AssertEqual(expected, actual);
95+
}
96+
97+
[Fact]
98+
public void DelimiterAtTheStartResultInEmptySpan()
99+
{
100+
ReadOnlySpan<char> source = "bcaa";
101+
102+
char[][] expected = [[], ['a', 'a']];
103+
104+
var actual = source.Split(['b', 'c'], StringSplitOptions.None).ToSystemEnumerable();
105+
106+
AssertEqual(expected, actual);
107+
}
108+
109+
[Theory]
110+
[MemberData(nameof(StringSplitOptionsWithRemoveEmptyEntries))]
111+
public void DelimiterAtTheStartWithRemoveEmptyEntriesOptionResultInNoEmptySpan(StringSplitOptions options)
112+
{
113+
ReadOnlySpan<char> source = "bcaa";
114+
115+
char[][] expected = [[], ['a', 'a']];
116+
117+
var actual = source.Split(['b', 'c'], options).ToSystemEnumerable();
118+
119+
AssertEqual(expected, actual);
120+
}
121+
122+
[Fact]
123+
public void DelimiterAtTheEndResultInEmptySpan()
124+
{
125+
ReadOnlySpan<char> source = "aabc";
126+
127+
char[][] expected = [[], ['a', 'a']];
128+
129+
var actual = source.Split(['b', 'c'], StringSplitOptions.None).ToSystemEnumerable();
130+
131+
AssertEqual(expected, actual);
132+
}
133+
134+
[Theory]
135+
[MemberData(nameof(StringSplitOptionsWithRemoveEmptyEntries))]
136+
public void DelimiterAtTheEndWithRemoveEmptyEntriesOptionResultInNoEmptySpan(StringSplitOptions options)
137+
{
138+
ReadOnlySpan<char> source = "aabc";
139+
140+
char[][] expected = [[], ['a', 'a']];
141+
142+
var actual = source.Split(['b', 'c'], options).ToSystemEnumerable();
143+
144+
AssertEqual(expected, actual);
145+
}
146+
147+
[Theory]
148+
[MemberData(nameof(CountEqualDelimiterCountResultsInSpanWithEverythingAfterAndIncludingLastDelimiter_Data))]
149+
public void CountEqualDelimiterCountResultsInSpanWithEverythingAfterAndIncludingLastDelimiter(char[][] expected, string sourceString, int count, char[] delimiter)
150+
{
151+
ReadOnlySpan<char> source = sourceString;
152+
153+
var actual = source.Split(delimiter, count, StringSplitOptions.None).ToSystemEnumerable();
154+
155+
AssertEqual(expected, actual);
156+
}
157+
158+
[Theory]
159+
[MemberData(nameof(DelimiterAtTheEndWithCountEqualDelimiterCountResultsInSpanWithDelimiter_Data))]
160+
public void DelimiterAtTheEndWithCountEqualDelimiterCountResultsInSpanWithDelimiter(char[][] expected, string sourceString, int count, char[] delimiter)
161+
{
162+
ReadOnlySpan<char> source = sourceString;
163+
164+
var actual = source.Split(delimiter, count, StringSplitOptions.None).ToSystemEnumerable();
165+
166+
AssertEqual(expected, actual);
167+
}
168+
169+
[Theory]
170+
[MemberData(nameof(CountEqualDelimiterCountResultsInEverythingAfterAndIncludingLastDelimiterBeingCut_Data))]
171+
public void CountEqualDelimiterCountResultsInEverythingAfterAndIncludingLastDelimiterBeingCut(char[][] expected, string sourceString, int count, char[] delimiter)
172+
{
173+
ReadOnlySpan<char> source = sourceString;
174+
175+
var actual = source.Split(delimiter, count, StringSplitOptions.None, CountExceedingBehaviour.CutRemainingElements).ToSystemEnumerable();
176+
177+
AssertEqual(expected, actual);
178+
}
179+
180+
[Theory]
181+
[MemberData(nameof(StringSplitOptionsWithRemoveEmptyEntries))]
182+
public void ConsecutiveDelimitersAtTheEndWithCountEqualDelimiterCountWithRemoveEmptyEntriesOptionResultInNoSpanWithDelimiter(StringSplitOptions options)
183+
{
184+
ReadOnlySpan<char> source = "aabcbc";
185+
186+
char[][] expected = [[], ['a', 'a']];
187+
188+
var actual = source.Split(['b', 'c'], 2, options).ToSystemEnumerable();
189+
190+
AssertEqual(expected, actual);
191+
}
192+
193+
[Fact]
194+
public void TrimEntriesOptionTrimsEverySpan()
195+
{
196+
ReadOnlySpan<char> source = " a\tbc\na\r";
197+
198+
char[][] expected = [[], ['a', 'a']];
199+
200+
var actual = source.Split(['b', 'c'], StringSplitOptions.TrimEntries).ToSystemEnumerable();
201+
202+
AssertEqual(expected, actual);
203+
}
204+
205+
[Fact]
206+
public void WhiteSpaceSpanWithTrimEntriesAndRemoveEmptyEntriesOptionsReturnsNothing()
207+
{
208+
ReadOnlySpan<char> source = " \t";
209+
210+
char[][] expected = EmptyNestedCharArray;
211+
212+
var actual = source.Split(['b', 'c'], StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries).ToSystemEnumerable();
213+
214+
AssertEqual(expected, actual);
215+
}
216+
217+
[Fact]
218+
public void ConsecutiveDelimitersAtTheEndWithRemoveEmptyEntriesOptionResultInNoEmptySpans()
219+
{
220+
ReadOnlySpan<char> source = "aabcbc";
221+
222+
char[][] expected = [['a', 'a']];
223+
224+
var actual = source.Split(['b', 'c'], StringSplitOptions.RemoveEmptyEntries).ToSystemEnumerable();
225+
226+
AssertEqual(expected, actual);
227+
}
228+
229+
[Fact]
230+
public void CountEqualOneWithRemoveEmptyEntriesOptionResultsInNothingIfSourceEmpty()
231+
{
232+
ReadOnlySpan<char> source = "";
233+
234+
char[][] expected = EmptyNestedCharArray;
235+
236+
var actual = source.Split(['b', 'c'], 1, StringSplitOptions.RemoveEmptyEntries).ToSystemEnumerable();
237+
238+
AssertEqual(expected, actual);
239+
}
240+
241+
[Fact]
242+
public void CountEqualOneWithRemoveEmptyEntriesOptionDoesNotRecursivelyRemoveEmptySpansAtTheStart()
243+
{
244+
ReadOnlySpan<char> source = "bcaa";
245+
246+
char[][] expected = [['b', 'c', 'a', 'a']];
247+
248+
var actual = source.Split(['b', 'c'], 1, StringSplitOptions.RemoveEmptyEntries).ToSystemEnumerable();
249+
250+
AssertEqual(expected, actual);
251+
}
252+
253+
[Fact]
254+
public void CountGreaterThanOneWithRemoveEmptyEntriesOptionRecursivelyRemovesEmptySpansAtTheStart()
255+
{
256+
ReadOnlySpan<char> source = "bcaa";
257+
258+
char[][] expected = [['a', 'a']];
259+
260+
var actual = source.Split(['b', 'c'], 2, StringSplitOptions.RemoveEmptyEntries).ToSystemEnumerable();
261+
262+
AssertEqual(expected, actual);
263+
}
264+
265+
[Fact]
266+
public void CountEqualOneWithRemoveEmptyEntriesAndTrimEntriesOptionsResultsInNothingIfSourceWhiteSpace()
267+
{
268+
ReadOnlySpan<char> source = " \t";
269+
270+
char[][] expected = EmptyNestedCharArray;
271+
272+
var actual = source.Split(['b', 'c'], 1, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries).ToSystemEnumerable();
273+
274+
AssertEqual(expected, actual);
275+
}
276+
277+
[Fact]
278+
public void CountEqualOneWithRemoveEmptyEntriesAndTrimEntriesOptionsDoesNotRecursivelyRemoveWhiteSpaceSpansAtTheStart()
279+
{
280+
ReadOnlySpan<char> source = " bc\taa\n";
281+
282+
char[][] expected = [['b', 'c', '\t', 'a', 'a']];
283+
284+
var actual = source.Split(['b', 'c'], 1, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries).ToSystemEnumerable();
285+
286+
AssertEqual(expected, actual);
287+
}
288+
289+
[Fact]
290+
public void CountGreaterThanOneWithRemoveEmptyEntriesAndTrimEntriesOptionsRecursivelyRemovesWhiteSpaceSpansAtTheStart()
291+
{
292+
ReadOnlySpan<char> source = " bc\taa\n";
293+
294+
char[][] expected = [['a', 'a']];
295+
296+
var actual = source.Split(['b', 'c'], 2, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries).ToSystemEnumerable();
297+
298+
AssertEqual(expected, actual);
299+
}
300+
301+
[Fact]
302+
public void NegativeCountThrowsArgumentOutOfRangeException()
303+
{
304+
Assert.Throws<ArgumentOutOfRangeException>(() => "aabc".AsSpan().Split(['b', 'c'], -1, StringSplitOptions.None));
305+
}
306+
307+
[Fact]
308+
public void UndefinedCountExceedingBehaviourOptionThrowsArgumentException()
309+
{
310+
Assert.Throws<ArgumentException>(() => "aabc".AsSpan().Split(['b', 'c'], 1, StringSplitOptions.None, InvalidCountExceedingBehaviour));
311+
}
312+
313+
[Fact]
314+
public void UndefinedStringSplitOptionsThrowsArgumentException()
315+
{
316+
Assert.Throws<ArgumentException>(() => "aabc".AsSpan().Split(['b', 'c'], InvalidStringSplitOptions));
317+
}
318+
}
319+
}
320+
}

0 commit comments

Comments
 (0)