updated benchmarks

dragon7307 · dragon7307 · commit 12a1c4b92852 · 2024-09-01T07:02:50.000+02:00
diff --git a/tests/Performance/Tests/ReadOnlySpan/Split/ReadOnlySpan_Split_Benchmark.cs b/tests/Performance/Tests/ReadOnlySpan/Split/ReadOnlySpan_Split_Benchmark.cs
@@ -9,28 +9,28 @@ public class ReadOnlySpan_Split_Benchmark
     [ArgumentsSource(nameof(GetArgsWithDelimiter))]
     public int Split_ReadOnlySpan(ReadOnlySpan<char> value, char delimiter)
     {
-        int length = 0;
+        int iterations = 0;
 
         foreach(ReadOnlySpan<char> part in value.Split(delimiter))
         {
-            length += part.Length;
+            iterations++;
         }
 
-        return length;
+        return iterations;
     }
 
     [Benchmark(Baseline = true)]
     [ArgumentsSource(nameof(GetArgsWithDelimiter))]
     public int Split_String(string value, char delimiter)
     {
-        int length = 0;
+        int iterations = 0;
 
         foreach(string part in value.Split(delimiter))
         {
-            length += part.Length;
+            iterations++;
         }
 
-        return length;
+        return iterations;
     }
 
     public IEnumerable<object[]> GetArgsWithDelimiter()
diff --git a/tests/Performance/Tests/ReadOnlySpan/Split/ReadOnlySpan_Split_Count_Benchmark.cs b/tests/Performance/Tests/ReadOnlySpan/Split/ReadOnlySpan_Split_Count_Benchmark.cs
@@ -9,42 +9,42 @@ public class ReadOnlySpan_Split_Count_Benchmark
     [ArgumentsSource(nameof(GetArgsWithDelimiterAndCount))]
     public int Split_ReadOnlySpan(ReadOnlySpan<char> value, char delimiter, int count)
     {
-        int length = 0;
+        int iterations = 0;
 
         foreach(ReadOnlySpan<char> part in value.Split(delimiter, count))
         {
-            length += part.Length;
+            iterations++;
         }
 
-        return length;
+        return iterations;
     }
 
     [Benchmark(Baseline = true)]
     [ArgumentsSource(nameof(GetArgsWithDelimiterAndCount))]
     public int Split_String(string value, char delimiter, int count)
     {
-        int length = 0;
+        int iterations = 0;
 
         foreach(string part in value.Split(delimiter, count))
         {
-            length += part.Length;
+            iterations++;
         }
 
-        return length;
+        return iterations;
     }
 
     [Benchmark]
     [ArgumentsSource(nameof(GetArgsWithDelimiterAndCount))]
     public int Split_CutLastElements_ReadOnlySpan(ReadOnlySpan<char> value, char delimiter, int count)
     {
-        int length = 0;
+        int iterations = 0;
 
         foreach(ReadOnlySpan<char> part in value.Split(delimiter, count, CountExceedingBehaviour.CutRemainingElements))
         {
-            length += part.Length;
+            iterations++;
         }
 
-        return length;
+        return iterations;
     }
 
     public IEnumerable<object[]> GetArgsWithDelimiterAndCount()
diff --git a/tests/Performance/Tests/ReadOnlySpan/Split/ReadOnlySpan_Split_Count_StringSplitOptions_Benchmark.cs b/tests/Performance/Tests/ReadOnlySpan/Split/ReadOnlySpan_Split_Count_StringSplitOptions_Benchmark.cs
@@ -9,42 +9,42 @@ public class ReadOnlySpan_Split_Count_StringSplitOptions_Benchmark
     [ArgumentsSource(nameof(GetArgsWithDelimiterAndCountAndStringSplitOptions))]
     public int Split_Count_StringSplitOptions_ReadOnlySpan(ReadOnlySpan<char> value, char delimiter, int count, StringSplitOptions options)
     {
-        int length = 0;
+        int iterations = 0;
 
         foreach(ReadOnlySpan<char> part in value.Split(delimiter, count, options))
         {
-            length += part.Length;
+            iterations++;
         }
 
-        return length;
+        return iterations;
     }
 
     [Benchmark(Baseline = true)]
     [ArgumentsSource(nameof(GetArgsWithDelimiterAndCountAndStringSplitOptions))]
     public int Split_Count_StringSplitOptions_String(string value, char delimiter, int count, StringSplitOptions options)
     {
-        int length = 0;
+        int iterations = 0;
 
         foreach(string part in value.Split(delimiter, count, options))
         {
-            length += part.Length;
+            iterations++;
         }
 
-        return length;
+        return iterations;
     }
 
     [Benchmark]
     [ArgumentsSource(nameof(GetArgsWithDelimiterAndCountAndStringSplitOptions))]
     public int Split_Count_StringSplitOptions_CountExceedingBehaviour_CutLastElements_ReadOnlySpan(ReadOnlySpan<char> value, char delimiter, int count, StringSplitOptions options)
     {
-        int length = 0;
+        int iterations = 0;
 
         foreach(ReadOnlySpan<char> part in value.Split(delimiter, count, options, CountExceedingBehaviour.CutRemainingElements))
         {
-            length += part.Length;
+            iterations++;
         }
 
-        return length;
+        return iterations;
     }
 
     public IEnumerable<object[]> GetArgsWithDelimiterAndCountAndStringSplitOptions()
diff --git a/tests/Performance/Tests/ReadOnlySpan/Split/ReadOnlySpan_Split_StringSplitOptions_Benchmark.cs b/tests/Performance/Tests/ReadOnlySpan/Split/ReadOnlySpan_Split_StringSplitOptions_Benchmark.cs
@@ -9,28 +9,28 @@ public class ReadOnlySpan_Split_StringSplitOptions_Benchmark
     [ArgumentsSource(nameof(GetArgsWithDelimiterAndStringSplitOptions))]
     public int Split_StringSplitOptions_ReadOnlySpan(ReadOnlySpan<char> value, char delimiter, StringSplitOptions options)
     {
-        int length = 0;
+        int iterations = 0;
 
         foreach(ReadOnlySpan<char> part in value.Split(delimiter, options))
         {
-            length += part.Length;
+            iterations++;
         }
 
-        return length;
+        return iterations;
     }
 
     [Benchmark(Baseline = true)]
     [ArgumentsSource(nameof(GetArgsWithDelimiterAndStringSplitOptions))]
     public int Split_StringSplitOptions_String(string value, char delimiter, StringSplitOptions options)
     {
-        int length = 0;
+        int iterations = 0;
 
         foreach(string part in value.Split(delimiter, options))
         {
-            length += part.Length;
+            iterations++;
         }
 
-        return length;
+        return iterations;
     }
 
     public IEnumerable<object[]> GetArgsWithDelimiterAndStringSplitOptions()
diff --git a/tests/Performance/Tests/ReadOnlySpan/SplitAny/ReadOnlySpan_Split_Any_Benchmark.cs b/tests/Performance/Tests/ReadOnlySpan/SplitAny/ReadOnlySpan_Split_Any_Benchmark.cs
@@ -9,36 +9,36 @@ public class ReadOnlySpan_Split_Any_Benchmark
         [ArgumentsSource(nameof(GetArgsWithDelimiter))]
         public int Split_Any_ReadOnlySpan(ReadOnlySpan<char> value, char[] delimiters)
         {
-            int length = 0;
+            int iterations = 0;
 
             foreach(ReadOnlySpan<char> part in value.SplitAny(delimiters))
             {
-                length += part.Length;
+                iterations++;
             }
 
-            return length;
+            return iterations;
         }
 
         [Benchmark(Baseline = true)]
         [ArgumentsSource(nameof(GetArgsWithDelimiter))]
         public int Split_Any_String(string value, char[] delimiters)
         {
-            int length = 0;
+            int iterations = 0;
 
             foreach(string part in value.Split(delimiters))
             {
-                length += part.Length;
+                iterations++;
             }
 
-            return length;
+            return iterations;
         }
 
         public IEnumerable<object[]> GetArgsWithDelimiter()
         {
-            yield return new object[] { "abcde", new object[] { 'b', 'd' } };
-            yield return new object[] { "abcdefg", new object[] { 'b', 'd', 'f' } };
-            yield return new object[] { "abba", new object[] { 'b', 'a' } };
-            yield return new object[] { "1234567890", new object[] { '1', '5', '7' } };
+            yield return ["abcde", new char[] { 'b', 'd' }];
+            yield return ["abcdefg", new char[] { 'b', 'd', 'f' }];
+            yield return ["abba", new char[] { 'b', 'a' } ];
+            yield return ["1234567890", new char[] { '1', '5', '7' }];
         }
     }
 }
diff --git a/tests/Performance/Tests/ReadOnlySpan/SplitAny/ReadOnlySpan_Split_Any_Count_Benchmark.cs b/tests/Performance/Tests/ReadOnlySpan/SplitAny/ReadOnlySpan_Split_Any_Count_Benchmark.cs
@@ -9,36 +9,36 @@ public class ReadOnlySpan_Split_Any_Count_Benchmark
         [ArgumentsSource(nameof(GetArgsWithDelimiter))]
         public int Split_Any_Count_ReadOnlySpan(ReadOnlySpan<char> value, char[] delimiters, int count)
         {
-            int length = 0;
+            int iterations = 0;
 
             foreach(ReadOnlySpan<char> part in value.SplitAny(delimiters, count))
             {
-                length += part.Length;
+                iterations++;
             }
 
-            return length;
+            return iterations;
         }
 
         [Benchmark(Baseline = true)]
         [ArgumentsSource(nameof(GetArgsWithDelimiter))]
         public int Split_Any_Count_String(string value, char[] delimiters, int count)
         {
-            int length = 0;
+            int iterations = 0;
 
             foreach(string part in value.Split(delimiters, count))
             {
-                length += part.Length;
+                iterations++;
             }
 
-            return length;
+            return iterations;
         }
 
         public IEnumerable<object[]> GetArgsWithDelimiter()
         {
-            yield return ["abcde", new object[] { 'b', 'd' }, 2];
-            yield return ["abcdefg", new object[] { 'b', 'd', 'f' }, 4];
-            yield return ["abba", new object[] { 'b', 'a' }, 2];
-            yield return ["1234567890", new object[] { '1', '5', '7' }, 1];
+            yield return ["abcde", new char[] { 'b', 'd' }, 2];
+            yield return ["abcdefg", new char[] { 'b', 'd', 'f' }, 4];
+            yield return ["abba", new char[] { 'b', 'a' }, 2];
+            yield return ["1234567890", new char[] { '1', '5', '7' }, 1];
         }
     }
 }
diff --git a/tests/Performance/Tests/ReadOnlySpan/SplitAny/ReadOnlySpan_Split_Any_Count_StringSplitOptions_Benchmark.cs b/tests/Performance/Tests/ReadOnlySpan/SplitAny/ReadOnlySpan_Split_Any_Count_StringSplitOptions_Benchmark.cs
@@ -9,40 +9,40 @@ public class ReadOnlySpan_Split_Any_Count_StringSplitOptions_Benchmark
         [ArgumentsSource(nameof(GetArgsWithDelimiter))]
         public int Split_Any_Count_ReadOnlySpan(ReadOnlySpan<char> value, char[] delimiters, int count, StringSplitOptions options)
         {
-            int length = 0;
+            int iterations = 0;
 
             foreach(ReadOnlySpan<char> part in value.SplitAny(delimiters, count, options))
             {
-                length += part.Length;
+                iterations++;
             }
 
-            return length;
+            return iterations;
         }
 
         [Benchmark(Baseline = true)]
         [ArgumentsSource(nameof(GetArgsWithDelimiter))]
         public int Split_Any_Count_String(string value, char[] delimiters, int count, StringSplitOptions options)
         {
-            int length = 0;
+            int iterations = 0;
 
             foreach(string part in value.Split(delimiters, count, options))
             {
-                length += part.Length;
+                iterations++;
             }
 
-            return length;
+            return iterations;
         }
 
         public IEnumerable<object[]> GetArgsWithDelimiter()
         {
-            yield return ["abcde", new object[] { 'b', 'd' }, 2, StringSplitOptions.None];
-            yield return ["abcdefg", new object[] { 'b', 'd', 4, 'f' }, StringSplitOptions.None];
-            yield return ["abba", new object[] { 'b', 'a' }, 2, StringSplitOptions.None];
-            yield return ["1234567890", new object[] { '1', '5', '7' }, 1, StringSplitOptions.None];
-            yield return ["abcde", new object[] { 'b', 'c' }, 4, StringSplitOptions.RemoveEmptyEntries];
-            yield return ["abba", new object[] { 'b', 'a' }, 1, StringSplitOptions.RemoveEmptyEntries];
-            yield return ["abba", new object[] { 'b', 'a' }, 3, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries];
-            yield return [" 1234 567890", new object[] { '1', '5', '7' }, 3, StringSplitOptions.TrimEntries];
+            yield return ["abcde", new char[] { 'b', 'd' }, 2, StringSplitOptions.None];
+            yield return ["abcdefg", new char[] { 'b', 'd', 'f' }, 4, StringSplitOptions.None];
+            yield return ["abba", new char[] { 'b', 'a' }, 2, StringSplitOptions.None];
+            yield return ["1234567890", new char[] { '1', '5', '7' }, 1, StringSplitOptions.None];
+            yield return ["abcde", new char[] { 'b', 'c' }, 4, StringSplitOptions.RemoveEmptyEntries];
+            yield return ["abba", new char[] { 'b', 'a' }, 1, StringSplitOptions.RemoveEmptyEntries];
+            yield return ["abba", new char[] { 'b', 'a' }, 3, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries];
+            yield return [" 1234 567890", new char[] { '1', '5', '7' }, 3, StringSplitOptions.TrimEntries];
         }
     }
 }
diff --git a/tests/Performance/Tests/ReadOnlySpan/SplitAny/ReadOnlySpan_Split_Any_StringSplitOptions_Benchmark.cs b/tests/Performance/Tests/ReadOnlySpan/SplitAny/ReadOnlySpan_Split_Any_StringSplitOptions_Benchmark.cs
@@ -9,39 +9,39 @@ public class ReadOnlySpan_Split_Any_StringSplitOptions_Benchmark
     [ArgumentsSource(nameof(GetArgsWithDelimiter))]
     public int Split_Any_Count_ReadOnlySpan(ReadOnlySpan<char> value, char[] delimiters, StringSplitOptions options)
     {
-        int length = 0;
+        int iterations = 0;
 
         foreach(ReadOnlySpan<char> part in value.SplitAny(delimiters, options))
         {
-            length += part.Length;
+            iterations++;
         }
 
-        return length;
+        return iterations;
     }
 
     [Benchmark(Baseline = true)]
     [ArgumentsSource(nameof(GetArgsWithDelimiter))]
     public int Split_Any_Count_String(string value, char[] delimiters, StringSplitOptions options)
     {
-        int length = 0;
+        int iterations = 0;
 
         foreach(string part in value.Split(delimiters, options))
         {
-            length += part.Length;
+            iterations++;
         }
 
-        return length;
+        return iterations;
     }
 
     public IEnumerable<object[]> GetArgsWithDelimiter()
     {
-        yield return ["abcde", new object[] { 'b', 'd' }, StringSplitOptions.None];
-        yield return ["abcdefg", new object[] { 'b', 'd', 'f' }, StringSplitOptions.None];
-        yield return ["abba", new object[] { 'b', 'a' }, StringSplitOptions.None];
-        yield return ["1234567890", new object[] { '1', '5', '7' }, StringSplitOptions.None];
-        yield return ["abcde", new object[] { 'b', 'c' }, StringSplitOptions.RemoveEmptyEntries];
-        yield return ["abba", new object[] { 'b', 'a' }, StringSplitOptions.RemoveEmptyEntries];
-        yield return ["abba", new object[] { 'b', 'a' }, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries];
-        yield return [" 1234 567890", new object[] { '1', '5', '7' }, StringSplitOptions.TrimEntries];
+        yield return ["abcde", new char[] { 'b', 'd' }, StringSplitOptions.None];
+        yield return ["abcdefg", new char[] { 'b', 'd', 'f' }, StringSplitOptions.None];
+        yield return ["abba", new char[] { 'b', 'a' }, StringSplitOptions.None];
+        yield return ["1234567890", new char[] { '1', '5', '7' }, StringSplitOptions.None];
+        yield return ["abcde", new char[] { 'b', 'c' }, StringSplitOptions.RemoveEmptyEntries];
+        yield return ["abba", new char[] { 'b', 'a' }, StringSplitOptions.RemoveEmptyEntries];
+        yield return ["abba", new char[] { 'b', 'a' }, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries];
+        yield return [" 1234 567890", new char[] { '1', '5', '7' }, StringSplitOptions.TrimEntries];
     }
 }
diff --git a/tests/Performance/Tests/ReadOnlySpan/SplitSequence/ReadOnlySpan_SplitSequence_Benchmark.cs b/tests/Performance/Tests/ReadOnlySpan/SplitSequence/ReadOnlySpan_SplitSequence_Benchmark.cs
diff --git a/tests/Performance/Tests/ReadOnlySpan/SplitSequence/ReadOnlySpan_SplitSequence_Count_Benchmark.cs b/tests/Performance/Tests/ReadOnlySpan/SplitSequence/ReadOnlySpan_SplitSequence_Count_Benchmark.cs
diff --git a/tests/Performance/Tests/ReadOnlySpan/SplitSequence/ReadOnlySpan_SplitSequence_Count_StringSplitOptions_Benchmark.cs b/tests/Performance/Tests/ReadOnlySpan/SplitSequence/ReadOnlySpan_SplitSequence_Count_StringSplitOptions_Benchmark.cs
diff --git a/tests/Performance/Tests/ReadOnlySpan/SplitSequence/ReadOnlySpan_SplitSequence_StringSplitOptions_Benchmark.cs b/tests/Performance/Tests/ReadOnlySpan/SplitSequence/ReadOnlySpan_SplitSequence_StringSplitOptions_Benchmark.cs

Original file line number	Diff line number	Diff line change
`@@ -9,28 +9,28 @@ public class ReadOnlySpan_Split_Benchmark`
`9`	`9`	`[ArgumentsSource(nameof(GetArgsWithDelimiter))]`
`10`	`10`	`public int Split_ReadOnlySpan(ReadOnlySpan<char> value, char delimiter)`
`11`	`11`	`{`
`12`		`- int length = 0;`
	`12`	`+ int iterations = 0;`
`13`	`13`
`14`	`14`	`foreach(ReadOnlySpan<char> part in value.Split(delimiter))`
`15`	`15`	`{`
`16`		`- length += part.Length;`
	`16`	`+ iterations++;`
`17`	`17`	`}`
`18`	`18`
`19`		`- return length;`
	`19`	`+ return iterations;`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`[Benchmark(Baseline = true)]`
`23`	`23`	`[ArgumentsSource(nameof(GetArgsWithDelimiter))]`
`24`	`24`	`public int Split_String(string value, char delimiter)`
`25`	`25`	`{`
`26`		`- int length = 0;`
	`26`	`+ int iterations = 0;`
`27`	`27`
`28`	`28`	`foreach(string part in value.Split(delimiter))`
`29`	`29`	`{`
`30`		`- length += part.Length;`
	`30`	`+ iterations++;`
`31`	`31`	`}`
`32`	`32`
`33`		`- return length;`
	`33`	`+ return iterations;`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`public IEnumerable<object[]> GetArgsWithDelimiter()`
Original file line number	Diff line number	Diff line change
`@@ -9,42 +9,42 @@ public class ReadOnlySpan_Split_Count_Benchmark`
`9`	`9`	`[ArgumentsSource(nameof(GetArgsWithDelimiterAndCount))]`
`10`	`10`	`public int Split_ReadOnlySpan(ReadOnlySpan<char> value, char delimiter, int count)`
`11`	`11`	`{`
`12`		`- int length = 0;`
	`12`	`+ int iterations = 0;`
`13`	`13`
`14`	`14`	`foreach(ReadOnlySpan<char> part in value.Split(delimiter, count))`
`15`	`15`	`{`
`16`		`- length += part.Length;`
	`16`	`+ iterations++;`
`17`	`17`	`}`
`18`	`18`
`19`		`- return length;`
	`19`	`+ return iterations;`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`[Benchmark(Baseline = true)]`
`23`	`23`	`[ArgumentsSource(nameof(GetArgsWithDelimiterAndCount))]`
`24`	`24`	`public int Split_String(string value, char delimiter, int count)`
`25`	`25`	`{`
`26`		`- int length = 0;`
	`26`	`+ int iterations = 0;`
`27`	`27`
`28`	`28`	`foreach(string part in value.Split(delimiter, count))`
`29`	`29`	`{`
`30`		`- length += part.Length;`
	`30`	`+ iterations++;`
`31`	`31`	`}`
`32`	`32`
`33`		`- return length;`
	`33`	`+ return iterations;`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`[Benchmark]`
`37`	`37`	`[ArgumentsSource(nameof(GetArgsWithDelimiterAndCount))]`
`38`	`38`	`public int Split_CutLastElements_ReadOnlySpan(ReadOnlySpan<char> value, char delimiter, int count)`
`39`	`39`	`{`
`40`		`- int length = 0;`
	`40`	`+ int iterations = 0;`
`41`	`41`
`42`	`42`	`foreach(ReadOnlySpan<char> part in value.Split(delimiter, count, CountExceedingBehaviour.CutRemainingElements))`
`43`	`43`	`{`
`44`		`- length += part.Length;`
	`44`	`+ iterations++;`
`45`	`45`	`}`
`46`	`46`
`47`		`- return length;`
	`47`	`+ return iterations;`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`public IEnumerable<object[]> GetArgsWithDelimiterAndCount()`
Original file line number	Diff line number	Diff line change
`@@ -9,36 +9,36 @@ public class ReadOnlySpan_Split_Any_Benchmark`
`9`	`9`	`[ArgumentsSource(nameof(GetArgsWithDelimiter))]`
`10`	`10`	`public int Split_Any_ReadOnlySpan(ReadOnlySpan<char> value, char[] delimiters)`
`11`	`11`	`{`
`12`		`- int length = 0;`
	`12`	`+ int iterations = 0;`
`13`	`13`
`14`	`14`	`foreach(ReadOnlySpan<char> part in value.SplitAny(delimiters))`
`15`	`15`	`{`
`16`		`- length += part.Length;`
	`16`	`+ iterations++;`
`17`	`17`	`}`
`18`	`18`
`19`		`- return length;`
	`19`	`+ return iterations;`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`[Benchmark(Baseline = true)]`
`23`	`23`	`[ArgumentsSource(nameof(GetArgsWithDelimiter))]`
`24`	`24`	`public int Split_Any_String(string value, char[] delimiters)`
`25`	`25`	`{`
`26`		`- int length = 0;`
	`26`	`+ int iterations = 0;`
`27`	`27`
`28`	`28`	`foreach(string part in value.Split(delimiters))`
`29`	`29`	`{`
`30`		`- length += part.Length;`
	`30`	`+ iterations++;`
`31`	`31`	`}`
`32`	`32`
`33`		`- return length;`
	`33`	`+ return iterations;`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`public IEnumerable<object[]> GetArgsWithDelimiter()`
`37`	`37`	`{`
`38`		`- yield return new object[] { "abcde", new object[] { 'b', 'd' } };`
`39`		`- yield return new object[] { "abcdefg", new object[] { 'b', 'd', 'f' } };`
`40`		`- yield return new object[] { "abba", new object[] { 'b', 'a' } };`
`41`		`- yield return new object[] { "1234567890", new object[] { '1', '5', '7' } };`
	`38`	`+ yield return ["abcde", new char[] { 'b', 'd' }];`
	`39`	`+ yield return ["abcdefg", new char[] { 'b', 'd', 'f' }];`
	`40`	`+ yield return ["abba", new char[] { 'b', 'a' } ];`
	`41`	`+ yield return ["1234567890", new char[] { '1', '5', '7' }];`
`42`	`42`	`}`
`43`	`43`	`}`
`44`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,40 +9,40 @@ public class ReadOnlySpan_Split_Any_Count_StringSplitOptions_Benchmark`
`9`	`9`	`[ArgumentsSource(nameof(GetArgsWithDelimiter))]`
`10`	`10`	`public int Split_Any_Count_ReadOnlySpan(ReadOnlySpan<char> value, char[] delimiters, int count, StringSplitOptions options)`
`11`	`11`	`{`
`12`		`- int length = 0;`
	`12`	`+ int iterations = 0;`
`13`	`13`
`14`	`14`	`foreach(ReadOnlySpan<char> part in value.SplitAny(delimiters, count, options))`
`15`	`15`	`{`
`16`		`- length += part.Length;`
	`16`	`+ iterations++;`
`17`	`17`	`}`
`18`	`18`
`19`		`- return length;`
	`19`	`+ return iterations;`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`[Benchmark(Baseline = true)]`
`23`	`23`	`[ArgumentsSource(nameof(GetArgsWithDelimiter))]`
`24`	`24`	`public int Split_Any_Count_String(string value, char[] delimiters, int count, StringSplitOptions options)`
`25`	`25`	`{`
`26`		`- int length = 0;`
	`26`	`+ int iterations = 0;`
`27`	`27`
`28`	`28`	`foreach(string part in value.Split(delimiters, count, options))`
`29`	`29`	`{`
`30`		`- length += part.Length;`
	`30`	`+ iterations++;`
`31`	`31`	`}`
`32`	`32`
`33`		`- return length;`
	`33`	`+ return iterations;`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`public IEnumerable<object[]> GetArgsWithDelimiter()`
`37`	`37`	`{`
`38`		`- yield return ["abcde", new object[] { 'b', 'd' }, 2, StringSplitOptions.None];`
`39`		`- yield return ["abcdefg", new object[] { 'b', 'd', 4, 'f' }, StringSplitOptions.None];`
`40`		`- yield return ["abba", new object[] { 'b', 'a' }, 2, StringSplitOptions.None];`
`41`		`- yield return ["1234567890", new object[] { '1', '5', '7' }, 1, StringSplitOptions.None];`
`42`		`- yield return ["abcde", new object[] { 'b', 'c' }, 4, StringSplitOptions.RemoveEmptyEntries];`
`43`		`- yield return ["abba", new object[] { 'b', 'a' }, 1, StringSplitOptions.RemoveEmptyEntries];`
`44`		`- yield return ["abba", new object[] { 'b', 'a' }, 3, StringSplitOptions.RemoveEmptyEntries \| StringSplitOptions.TrimEntries];`
`45`		`- yield return [" 1234 567890", new object[] { '1', '5', '7' }, 3, StringSplitOptions.TrimEntries];`
	`38`	`+ yield return ["abcde", new char[] { 'b', 'd' }, 2, StringSplitOptions.None];`
	`39`	`+ yield return ["abcdefg", new char[] { 'b', 'd', 'f' }, 4, StringSplitOptions.None];`
	`40`	`+ yield return ["abba", new char[] { 'b', 'a' }, 2, StringSplitOptions.None];`
	`41`	`+ yield return ["1234567890", new char[] { '1', '5', '7' }, 1, StringSplitOptions.None];`
	`42`	`+ yield return ["abcde", new char[] { 'b', 'c' }, 4, StringSplitOptions.RemoveEmptyEntries];`
	`43`	`+ yield return ["abba", new char[] { 'b', 'a' }, 1, StringSplitOptions.RemoveEmptyEntries];`
	`44`	`+ yield return ["abba", new char[] { 'b', 'a' }, 3, StringSplitOptions.RemoveEmptyEntries \| StringSplitOptions.TrimEntries];`
	`45`	`+ yield return [" 1234 567890", new char[] { '1', '5', '7' }, 3, StringSplitOptions.TrimEntries];`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,39 +9,39 @@ public class ReadOnlySpan_Split_Any_StringSplitOptions_Benchmark`
`9`	`9`	`[ArgumentsSource(nameof(GetArgsWithDelimiter))]`
`10`	`10`	`public int Split_Any_Count_ReadOnlySpan(ReadOnlySpan<char> value, char[] delimiters, StringSplitOptions options)`
`11`	`11`	`{`
`12`		`- int length = 0;`
	`12`	`+ int iterations = 0;`
`13`	`13`
`14`	`14`	`foreach(ReadOnlySpan<char> part in value.SplitAny(delimiters, options))`
`15`	`15`	`{`
`16`		`- length += part.Length;`
	`16`	`+ iterations++;`
`17`	`17`	`}`
`18`	`18`
`19`		`- return length;`
	`19`	`+ return iterations;`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`[Benchmark(Baseline = true)]`
`23`	`23`	`[ArgumentsSource(nameof(GetArgsWithDelimiter))]`
`24`	`24`	`public int Split_Any_Count_String(string value, char[] delimiters, StringSplitOptions options)`
`25`	`25`	`{`
`26`		`- int length = 0;`
	`26`	`+ int iterations = 0;`
`27`	`27`
`28`	`28`	`foreach(string part in value.Split(delimiters, options))`
`29`	`29`	`{`
`30`		`- length += part.Length;`
	`30`	`+ iterations++;`
`31`	`31`	`}`
`32`	`32`
`33`		`- return length;`
	`33`	`+ return iterations;`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`public IEnumerable<object[]> GetArgsWithDelimiter()`
`37`	`37`	`{`
`38`		`- yield return ["abcde", new object[] { 'b', 'd' }, StringSplitOptions.None];`
`39`		`- yield return ["abcdefg", new object[] { 'b', 'd', 'f' }, StringSplitOptions.None];`
`40`		`- yield return ["abba", new object[] { 'b', 'a' }, StringSplitOptions.None];`
`41`		`- yield return ["1234567890", new object[] { '1', '5', '7' }, StringSplitOptions.None];`
`42`		`- yield return ["abcde", new object[] { 'b', 'c' }, StringSplitOptions.RemoveEmptyEntries];`
`43`		`- yield return ["abba", new object[] { 'b', 'a' }, StringSplitOptions.RemoveEmptyEntries];`
`44`		`- yield return ["abba", new object[] { 'b', 'a' }, StringSplitOptions.RemoveEmptyEntries \| StringSplitOptions.TrimEntries];`
`45`		`- yield return [" 1234 567890", new object[] { '1', '5', '7' }, StringSplitOptions.TrimEntries];`
	`38`	`+ yield return ["abcde", new char[] { 'b', 'd' }, StringSplitOptions.None];`
	`39`	`+ yield return ["abcdefg", new char[] { 'b', 'd', 'f' }, StringSplitOptions.None];`
	`40`	`+ yield return ["abba", new char[] { 'b', 'a' }, StringSplitOptions.None];`
	`41`	`+ yield return ["1234567890", new char[] { '1', '5', '7' }, StringSplitOptions.None];`
	`42`	`+ yield return ["abcde", new char[] { 'b', 'c' }, StringSplitOptions.RemoveEmptyEntries];`
	`43`	`+ yield return ["abba", new char[] { 'b', 'a' }, StringSplitOptions.RemoveEmptyEntries];`
	`44`	`+ yield return ["abba", new char[] { 'b', 'a' }, StringSplitOptions.RemoveEmptyEntries \| StringSplitOptions.TrimEntries];`
	`45`	`+ yield return [" 1234 567890", new char[] { '1', '5', '7' }, StringSplitOptions.TrimEntries];`
`46`	`46`	`}`
`47`	`47`	`}`