diff --git a/eng/CodeAnalysis.ruleset b/eng/CodeAnalysis.ruleset
index 0fccc15fc7494a..cf97025667a2bd 100644
--- a/eng/CodeAnalysis.ruleset
+++ b/eng/CodeAnalysis.ruleset
@@ -336,7 +336,6 @@
-
diff --git a/src/libraries/Common/tests/System/IO/Compression/CompressionStreamUnitTestBase.cs b/src/libraries/Common/tests/System/IO/Compression/CompressionStreamUnitTestBase.cs
index 1469c64401aa06..053d8d39360871 100644
--- a/src/libraries/Common/tests/System/IO/Compression/CompressionStreamUnitTestBase.cs
+++ b/src/libraries/Common/tests/System/IO/Compression/CompressionStreamUnitTestBase.cs
@@ -664,18 +664,18 @@ public static IEnumerable RoundtripCompressDecompressOuterData
[Fact]
public async Task CompressDecompress_RoundTrip()
{
- await CompressDecompress_RoundTrip(ReadWriteMode.SyncArray, chunkSize: 1, totalSize: 10, level: CompressionLevel.Fastest);
- await CompressDecompress_RoundTrip(ReadWriteMode.SyncSpan, chunkSize: 1, totalSize: 10, level: CompressionLevel.Fastest);
- await CompressDecompress_RoundTrip(ReadWriteMode.AsyncArray, chunkSize: 1, totalSize: 10, level: CompressionLevel.Fastest);
- await CompressDecompress_RoundTrip(ReadWriteMode.AsyncMemory, chunkSize: 1, totalSize: 10, level: CompressionLevel.Fastest);
- await CompressDecompress_RoundTrip(ReadWriteMode.AsyncBeginEnd, chunkSize: 1, totalSize: 10, level: CompressionLevel.Fastest);
- await CompressDecompress_RoundTrip(ReadWriteMode.AsyncArray, chunkSize: 1024, totalSize: 8192, level: CompressionLevel.Optimal);
+ await CompressDecompress_RoundTrip_OuterLoop(ReadWriteMode.SyncArray, chunkSize: 1, totalSize: 10, level: CompressionLevel.Fastest);
+ await CompressDecompress_RoundTrip_OuterLoop(ReadWriteMode.SyncSpan, chunkSize: 1, totalSize: 10, level: CompressionLevel.Fastest);
+ await CompressDecompress_RoundTrip_OuterLoop(ReadWriteMode.AsyncArray, chunkSize: 1, totalSize: 10, level: CompressionLevel.Fastest);
+ await CompressDecompress_RoundTrip_OuterLoop(ReadWriteMode.AsyncMemory, chunkSize: 1, totalSize: 10, level: CompressionLevel.Fastest);
+ await CompressDecompress_RoundTrip_OuterLoop(ReadWriteMode.AsyncBeginEnd, chunkSize: 1, totalSize: 10, level: CompressionLevel.Fastest);
+ await CompressDecompress_RoundTrip_OuterLoop(ReadWriteMode.AsyncArray, chunkSize: 1024, totalSize: 8192, level: CompressionLevel.Optimal);
}
[OuterLoop]
[Theory]
[MemberData(nameof(RoundtripCompressDecompressOuterData))]
- public async Task CompressDecompress_RoundTrip(ReadWriteMode readWriteMode, int chunkSize, int totalSize, CompressionLevel level)
+ public async Task CompressDecompress_RoundTrip_OuterLoop(ReadWriteMode readWriteMode, int chunkSize, int totalSize, CompressionLevel level)
{
byte[] data = new byte[totalSize];
new Random(42).NextBytes(data);
@@ -715,14 +715,14 @@ public async Task Flush_RoundTrip()
{
if (FlushNoOps)
return;
- await Flush_RoundTrip(ReadWriteMode.SyncArray, chunkSize: 1, totalSize: 10, level: CompressionLevel.Fastest);
- await Flush_RoundTrip(ReadWriteMode.AsyncArray, chunkSize: 1024, totalSize: 8192, level: CompressionLevel.Optimal);
+ await Flush_RoundTrip_OuterLoop(ReadWriteMode.SyncArray, chunkSize: 1, totalSize: 10, level: CompressionLevel.Fastest);
+ await Flush_RoundTrip_OuterLoop(ReadWriteMode.AsyncArray, chunkSize: 1024, totalSize: 8192, level: CompressionLevel.Optimal);
}
[OuterLoop]
[Theory]
[MemberData(nameof(RoundtripCompressDecompressOuterData))]
- public async Task Flush_RoundTrip(ReadWriteMode readWriteMode, int chunkSize, int totalSize, CompressionLevel level)
+ public async Task Flush_RoundTrip_OuterLoop(ReadWriteMode readWriteMode, int chunkSize, int totalSize, CompressionLevel level)
{
if (FlushNoOps)
return;
@@ -777,14 +777,14 @@ public async Task Flush_Consecutive()
{
if (FlushNoOps)
return;
- await Flush_Consecutive(ReadWriteMode.SyncArray, chunkSize: 1, totalSize: 10, level: CompressionLevel.Fastest);
- await Flush_Consecutive(ReadWriteMode.AsyncArray, chunkSize: 1024, totalSize: 8192, level: CompressionLevel.Optimal);
+ await Flush_Consecutive_OuterLoop(ReadWriteMode.SyncArray, chunkSize: 1, totalSize: 10, level: CompressionLevel.Fastest);
+ await Flush_Consecutive_OuterLoop(ReadWriteMode.AsyncArray, chunkSize: 1024, totalSize: 8192, level: CompressionLevel.Optimal);
}
[OuterLoop]
[Theory]
[MemberData(nameof(RoundtripCompressDecompressOuterData))]
- public async Task Flush_Consecutive(ReadWriteMode readWriteMode, int chunkSize, int totalSize, CompressionLevel level)
+ public async Task Flush_Consecutive_OuterLoop(ReadWriteMode readWriteMode, int chunkSize, int totalSize, CompressionLevel level)
{
if (FlushNoOps)
return;
@@ -851,14 +851,14 @@ public async Task Flush_BeforeFirstWrites()
{
if (FlushNoOps)
return;
- await Flush_BeforeFirstWrites(ReadWriteMode.SyncArray, chunkSize: 1, totalSize: 10, level: CompressionLevel.Fastest);
- await Flush_BeforeFirstWrites(ReadWriteMode.AsyncArray, chunkSize: 1024, totalSize: 8192, level: CompressionLevel.Optimal);
+ await Flush_BeforeFirstWrites_OuterLoop(ReadWriteMode.SyncArray, chunkSize: 1, totalSize: 10, level: CompressionLevel.Fastest);
+ await Flush_BeforeFirstWrites_OuterLoop(ReadWriteMode.AsyncArray, chunkSize: 1024, totalSize: 8192, level: CompressionLevel.Optimal);
}
[OuterLoop]
[Theory]
[MemberData(nameof(RoundtripCompressDecompressOuterData))]
- public async Task Flush_BeforeFirstWrites(ReadWriteMode readWriteMode, int chunkSize, int totalSize, CompressionLevel level)
+ public async Task Flush_BeforeFirstWrites_OuterLoop(ReadWriteMode readWriteMode, int chunkSize, int totalSize, CompressionLevel level)
{
if (FlushNoOps)
return;
@@ -1168,7 +1168,7 @@ private async Task CopyTo_Roundtrip_OutputMatchesInput_Verify(byte[] expectedDec
[Theory]
[InlineData(CompressionMode.Compress)]
[InlineData(CompressionMode.Decompress)]
- public void BaseStream(CompressionMode mode)
+ public void BaseStreamTest(CompressionMode mode)
{
using (var baseStream = new MemoryStream())
using (var compressor = CreateStream(baseStream, mode))
diff --git a/src/libraries/Common/tests/Tests/System/StringTests.cs b/src/libraries/Common/tests/Tests/System/StringTests.cs
index ba1757f67c1274..c32350dbdd3a3c 100644
--- a/src/libraries/Common/tests/Tests/System/StringTests.cs
+++ b/src/libraries/Common/tests/Tests/System/StringTests.cs
@@ -1119,7 +1119,7 @@ public static void CompareOrdinal_NegativeLength_ThrowsArgumentOutOfRangeExcepti
[InlineData("", "", true)]
[InlineData("", "hello", false)]
[InlineData("Hello", "", true)]
- public static void Contains(string s, string value, bool expected)
+ public static void Contains_String(string s, string value, bool expected)
{
Assert.Equal(expected, s.Contains(value));
Assert.Equal(expected, s.AsSpan().Contains(value.AsSpan(), StringComparison.Ordinal));
@@ -1666,7 +1666,7 @@ public static void MakeSureNoSequenceEqualChecksGoOutOfRange_Char()
[InlineData("Hello", "llo" + SoftHyphen, StringComparison.OrdinalIgnoreCase, false)]
[InlineData("", "", StringComparison.OrdinalIgnoreCase, true)]
[InlineData("", "a", StringComparison.OrdinalIgnoreCase, false)]
- public static void EndsWith(string s, string value, StringComparison comparisonType, bool expected)
+ public static void EndsWith_StringComparison(string s, string value, StringComparison comparisonType, bool expected)
{
if (comparisonType == StringComparison.CurrentCulture)
{
@@ -2482,7 +2482,7 @@ public static void GetHashCode_EmbeddedNull_ReturnsDifferentHashCodes()
[InlineData("", "", StringComparison.OrdinalIgnoreCase, true)]
[InlineData("123", 123, StringComparison.OrdinalIgnoreCase, false)] // Not a string
[InlineData("\0AAAAAAAAA", "\0BBBBBBBBBBBB", StringComparison.OrdinalIgnoreCase, false)]
- public static void Equals(string s1, object obj, StringComparison comparisonType, bool expected)
+ public static void EqualsTest(string s1, object obj, StringComparison comparisonType, bool expected)
{
string s2 = obj as string;
if (s1 != null)
@@ -4516,7 +4516,7 @@ public static void Remove_Invalid()
"Mauris nulla sapien, convallis et quam quis, accumsan sodales mi. Praesent dapibus urna fermentum, sollicitudin posuere.",
'e', 'E',
"LorEm ipsum dolor sit amEt, consEctEtur adipiscing Elit. Proin maximus convallis luctus. Curabitur porttitor mi blandit tEllus maximus varius. " +
- "Mauris nulla sapiEn, convallis Et quam quis, accumsan sodalEs mi. PraEsEnt dapibus urna fErmEntum, sollicitudin posuErE.")]
+ "Mauris nulla sapiEn, convallis Et quam quis, accumsan sodalEs mi. PraEsEnt dapibus urna fErmEntum, sollicitudin posuErE.")]
public static void Replace_Char_Char(string s, char oldChar, char newChar, string expected)
{
Assert.Equal(expected, s.Replace(oldChar, newChar));
@@ -4637,7 +4637,7 @@ public void Replace_EmptyOldValue_ThrowsArgumentException()
[InlineData("Hello", SoftHyphen + "Hel", StringComparison.OrdinalIgnoreCase, false)]
[InlineData("", "", StringComparison.OrdinalIgnoreCase, true)]
[InlineData("", "hello", StringComparison.OrdinalIgnoreCase, false)]
- public static void StartsWith(string s, string value, StringComparison comparisonType, bool expected)
+ public static void StartsWith_StringComparison(string s, string value, StringComparison comparisonType, bool expected)
{
if (comparisonType == StringComparison.CurrentCulture)
{
@@ -5016,7 +5016,7 @@ public static void ToCharArray_Invalid()
[InlineData("hElLo", "hello")]
[InlineData("HeLlO", "hello")]
[InlineData("", "")]
- public static void ToLower(string s, string expected)
+ public static void ToLower_String(string s, string expected)
{
Assert.Equal(expected, s.ToLower());
@@ -5123,7 +5123,7 @@ public static void SameSpanToLower()
Assert.Equal(expected, s1.ToLower(CultureInfo.CurrentCulture).ToArray());
Assert.Equal(expected, s1.ToLowerInvariant().ToArray());
{
- AssertExtensions.AssertThrows(a, a =>
+ AssertExtensions.AssertThrows(a, a =>
{
ReadOnlySpan source = a;
Span destination = a;
@@ -5156,7 +5156,7 @@ public static void ToLowerOverlapping()
var source = new ReadOnlySpan(a, 1, 3);
AssertExtensions.AssertThrows(source, source =>
- {
+ {
var destination = new Span(a, 3, 3);
source.ToLower(destination, CultureInfo.CurrentCulture);
});
@@ -5220,7 +5220,7 @@ public static void LengthMismatchToLower()
}
[Fact]
- public static void ToLower()
+ public static void ToLower_CharArray()
{
var expectedSource = new char[3] { 'a', 'B', 'c' };
var expectedDestination = new char[3] { 'a', 'b', 'c' };
@@ -5432,7 +5432,7 @@ public static void LengthMismatchToUpper()
}
[Fact]
- public static void ToUpper()
+ public static void ToUpper_CharArray()
{
var expectedSource = new char[3] { 'a', 'B', 'c' };
var expectedDestination = new char[3] { 'A', 'B', 'C' };
@@ -5542,7 +5542,7 @@ public static void Test_ToUpper_Culture(string actual, string expected, CultureI
[Theory]
[InlineData("")]
[InlineData("hello")]
- public static void ToString(string s)
+ public static void ToStringTest(string s)
{
Assert.Same(s, s.ToString());
Assert.Same(s, s.ToString(null));
@@ -5557,7 +5557,7 @@ public static void ToString(string s)
[InlineData("hElLo", "HELLO")]
[InlineData("HeLlO", "HELLO")]
[InlineData("", "")]
- public static void ToUpper(string s, string expected)
+ public static void ToUpper_String(string s, string expected)
{
Assert.Equal(expected, s.ToUpper());
diff --git a/src/libraries/Microsoft.VisualBasic.Core/tests/ConversionTests.cs b/src/libraries/Microsoft.VisualBasic.Core/tests/ConversionTests.cs
index 3b9e40850ad327..ebb59e3e2e107b 100644
--- a/src/libraries/Microsoft.VisualBasic.Core/tests/ConversionTests.cs
+++ b/src/libraries/Microsoft.VisualBasic.Core/tests/ConversionTests.cs
@@ -141,7 +141,7 @@ public void ErrorToString()
[InlineData(-1)]
[InlineData(7)]
[InlineData(int.MinValue)]
- public void ErrorToString(int errorNumber)
+ public void ErrorToString_WithErrorNumber(int errorNumber)
{
Assert.NotNull(Conversion.ErrorToString(errorNumber));
}
@@ -165,49 +165,49 @@ public void ErrorToString_ArgumentException(int errorNumber)
[MemberData(nameof(Fix_Single_TestData))]
[MemberData(nameof(Fix_Double_TestData))]
[MemberData(nameof(Fix_Decimal_TestData))]
- public void Fix(object value, object expected)
+ public void Fix_Object(object value, object expected)
{
Assert.Equal(expected, Conversion.Fix(value));
}
[Theory]
[MemberData(nameof(Fix_Short_TestData))]
- public void Fix(short value, short expected)
+ public void Fix_Short(short value, short expected)
{
Assert.Equal(expected, Conversion.Fix(value));
}
[Theory]
[MemberData(nameof(Fix_Integer_TestData))]
- public void Fix(int value, int expected)
+ public void Fix_Int(int value, int expected)
{
Assert.Equal(expected, Conversion.Fix(value));
}
[Theory]
[MemberData(nameof(Fix_Long_TestData))]
- public void Fix(long value, long expected)
+ public void Fix_Long(long value, long expected)
{
Assert.Equal(expected, Conversion.Fix(value));
}
[Theory]
[MemberData(nameof(Fix_Single_TestData))]
- public void Fix(float value, float expected)
+ public void Fix_Float(float value, float expected)
{
Assert.Equal(expected, Conversion.Fix(value));
}
[Theory]
[MemberData(nameof(Fix_Double_TestData))]
- public void Fix(double value, double expected)
+ public void Fix_Double(double value, double expected)
{
Assert.Equal(expected, Conversion.Fix(value));
}
[Theory]
[MemberData(nameof(Fix_Decimal_TestData))]
- public void Fix(decimal value, decimal expected)
+ public void Fix_Decimal(decimal value, decimal expected)
{
Assert.Equal(expected, Conversion.Fix(value));
}
@@ -305,56 +305,56 @@ public static IEnumerable Fix_Decimal_TestData()
[MemberData(nameof(Hex_Single_TestData))]
[MemberData(nameof(Hex_Double_TestData))]
[MemberData(nameof(Hex_Decimal_TestData))]
- public void Hex(object value, string expected)
+ public void Hex_Object(object value, string expected)
{
Assert.Equal(expected, Conversion.Hex(value));
}
[Theory]
[MemberData(nameof(Hex_Byte_TestData))]
- public void Hex(byte value, string expected)
+ public void Hex_Byte(byte value, string expected)
{
Assert.Equal(expected, Conversion.Hex(value));
}
[Theory]
[MemberData(nameof(Hex_SByte_TestData))]
- public void Hex(sbyte value, string expected)
+ public void Hex_Sbyte(sbyte value, string expected)
{
Assert.Equal(expected, Conversion.Hex(value));
}
[Theory]
[MemberData(nameof(Hex_UShort_TestData))]
- public void Hex(ushort value, string expected)
+ public void Hex_Ushort(ushort value, string expected)
{
Assert.Equal(expected, Conversion.Hex(value));
}
[Theory]
[MemberData(nameof(Hex_Short_TestData))]
- public void Hex(short value, string expected)
+ public void Hex_Short(short value, string expected)
{
Assert.Equal(expected, Conversion.Hex(value));
}
[Theory]
[MemberData(nameof(Hex_UInteger_TestData))]
- public void Hex(uint value, string expected)
+ public void Hex_Uint(uint value, string expected)
{
Assert.Equal(expected, Conversion.Hex(value));
}
[Theory]
[MemberData(nameof(Hex_Integer_TestData))]
- public void Hex(int value, string expected)
+ public void Hex_Int(int value, string expected)
{
Assert.Equal(expected, Conversion.Hex(value));
}
[Theory]
[MemberData(nameof(Hex_ULong_TestData))]
- public void Hex(ulong value, string expected)
+ public void Hex_Ulong(ulong value, string expected)
{
Assert.Equal(expected, Conversion.Hex(value));
}
@@ -362,28 +362,28 @@ public void Hex(ulong value, string expected)
[Theory]
[InlineData((long)-1, "FFFFFFFFFFFFFFFF")] // expected for object overload: "FFFFFFFF"
[MemberData(nameof(Hex_Long_TestData))]
- public void Hex(long value, string expected)
+ public void Hex_Long(long value, string expected)
{
Assert.Equal(expected, Conversion.Hex(value));
}
[Theory]
[MemberData(nameof(Hex_Single_TestData))]
- public void Hex(float value, string expected)
+ public void Hex_Float(float value, string expected)
{
Assert.Equal(expected, Conversion.Hex(value));
}
[Theory]
[MemberData(nameof(Hex_Double_TestData))]
- public void Hex(double value, string expected)
+ public void Hex_Double(double value, string expected)
{
Assert.Equal(expected, Conversion.Hex(value));
}
[Theory]
[MemberData(nameof(Hex_Decimal_TestData))]
- public void Hex(decimal value, string expected)
+ public void Hex_Decimal(decimal value, string expected)
{
Assert.Equal(expected, Conversion.Hex(value));
}
@@ -502,49 +502,49 @@ public static IEnumerable Hex_Decimal_TestData()
[MemberData(nameof(Int_Single_TestData))]
[MemberData(nameof(Int_Double_TestData))]
[MemberData(nameof(Int_Decimal_TestData))]
- public void Int(object value, object expected)
+ public void Int_Object_Object(object value, object expected)
{
Assert.Equal(expected, Conversion.Int(value));
}
[Theory]
[MemberData(nameof(Int_Short_TestData))]
- public void Int(short value, short expected)
+ public void Int_Short(short value, short expected)
{
Assert.Equal(expected, Conversion.Int(value));
}
[Theory]
[MemberData(nameof(Int_Integer_TestData))]
- public void Int(int value, int expected)
+ public void Int_Int(int value, int expected)
{
Assert.Equal(expected, Conversion.Int(value));
}
[Theory]
[MemberData(nameof(Int_Long_TestData))]
- public void Int(long value, long expected)
+ public void Int_Long(long value, long expected)
{
Assert.Equal(expected, Conversion.Int(value));
}
[Theory]
[MemberData(nameof(Int_Single_TestData))]
- public void Int(float value, float expected)
+ public void Int_Float(float value, float expected)
{
Assert.Equal(expected, Conversion.Int(value));
}
[Theory]
[MemberData(nameof(Int_Double_TestData))]
- public void Int(double value, double expected)
+ public void Int_Double(double value, double expected)
{
Assert.Equal(expected, Conversion.Int(value));
}
[Theory]
[MemberData(nameof(Int_Decimal_TestData))]
- public void Int(decimal value, decimal expected)
+ public void Int_Decimal(decimal value, decimal expected)
{
Assert.Equal(expected, Conversion.Int(value));
}
@@ -636,56 +636,56 @@ public static IEnumerable Int_Decimal_TestData()
[MemberData(nameof(Oct_Single_TestData))]
[MemberData(nameof(Oct_Double_TestData))]
[MemberData(nameof(Oct_Decimal_TestData))]
- public void Oct(object value, string expected)
+ public void Oct_Object(object value, string expected)
{
Assert.Equal(expected, Conversion.Oct(value));
}
[Theory]
[MemberData(nameof(Oct_Byte_TestData))]
- public void Oct(byte value, string expected)
+ public void Oct_Byte(byte value, string expected)
{
Assert.Equal(expected, Conversion.Oct(value));
}
[Theory]
[MemberData(nameof(Oct_SByte_TestData))]
- public void Oct(sbyte value, string expected)
+ public void Oct_Sbyte(sbyte value, string expected)
{
Assert.Equal(expected, Conversion.Oct(value));
}
[Theory]
[MemberData(nameof(Oct_UShort_TestData))]
- public void Oct(ushort value, string expected)
+ public void Oct_Ushort(ushort value, string expected)
{
Assert.Equal(expected, Conversion.Oct(value));
}
[Theory]
[MemberData(nameof(Oct_Short_TestData))]
- public void Oct(short value, string expected)
+ public void Oct_Short(short value, string expected)
{
Assert.Equal(expected, Conversion.Oct(value));
}
[Theory]
[MemberData(nameof(Oct_UInteger_TestData))]
- public void Oct(uint value, string expected)
+ public void Oct_Uint(uint value, string expected)
{
Assert.Equal(expected, Conversion.Oct(value));
}
[Theory]
[MemberData(nameof(Oct_Integer_TestData))]
- public void Oct(int value, string expected)
+ public void Oct_Int(int value, string expected)
{
Assert.Equal(expected, Conversion.Oct(value));
}
[Theory]
[MemberData(nameof(Oct_ULong_TestData))]
- public void Oct(ulong value, string expected)
+ public void Oct_Ulong(ulong value, string expected)
{
Assert.Equal(expected, Conversion.Oct(value));
}
@@ -693,28 +693,28 @@ public void Oct(ulong value, string expected)
[Theory]
[InlineData((long)-1, "1777777777777777777777")] // expected for object overload: "37777777777"
[MemberData(nameof(Oct_Long_TestData))]
- public void Oct(long value, string expected)
+ public void Oct_Long(long value, string expected)
{
Assert.Equal(expected, Conversion.Oct(value));
}
[Theory]
[MemberData(nameof(Oct_Single_TestData))]
- public void Oct(float value, string expected)
+ public void Oct_Float(float value, string expected)
{
Assert.Equal(expected, Conversion.Oct(value));
}
[Theory]
[MemberData(nameof(Oct_Double_TestData))]
- public void Oct(double value, string expected)
+ public void Oct_Double(double value, string expected)
{
Assert.Equal(expected, Conversion.Oct(value));
}
[Theory]
[MemberData(nameof(Oct_Decimal_TestData))]
- public void Oct(decimal value, string expected)
+ public void Oct_Decimal(decimal value, string expected)
{
Assert.Equal(expected, Conversion.Oct(value));
}
@@ -868,56 +868,56 @@ public static IEnumerable Str_Object_InvalidCastException_TestData()
[MemberData(nameof(Val_Object_TestData))]
[MemberData(nameof(Val_Char_TestData))]
[MemberData(nameof(Val_String_TestData))]
- public void Val(object value, double expected)
+ public void Val_Object_Double(object value, double expected)
{
Assert.Equal(expected, Conversion.Val(value));
}
[Theory]
[MemberData(nameof(Val_Object_ArgumentException_TestData))]
- public void Val_ArgumentException(object value)
+ public void Val_ArgumentException_Object(object value)
{
Assert.Throws(() => Conversion.Val(value));
}
[Theory]
[MemberData(nameof(Val_Object_OverflowException_TestData))]
- public void Val_OverflowException(object value)
+ public void Val_OverflowException_Object(object value)
{
Assert.Throws(() => Conversion.Val(value));
}
[Theory]
[MemberData(nameof(Val_Char_TestData))]
- public void Val(char value, int expected)
+ public void Val_Char_Int(char value, int expected)
{
Assert.Equal(expected, Conversion.Val(value));
}
[Theory]
[MemberData(nameof(Val_Char_ArgumentException_TestData))]
- public void Val_ArgumentException(char value)
+ public void Val_ArgumentException_Char(char value)
{
Assert.Throws(() => Conversion.Val(value));
}
[Theory]
[MemberData(nameof(Val_Char_OverflowException_TestData))]
- public void Val_OverflowException(char value)
+ public void Val_OverflowException_Char(char value)
{
Assert.Throws(() => Conversion.Val(value));
}
[Theory]
[MemberData(nameof(Val_String_TestData))]
- public void Val(string value, double expected)
+ public void Val_String_Double(string value, double expected)
{
Assert.Equal(expected, Conversion.Val(value));
}
[Theory]
[MemberData(nameof(Val_String_ArgumentException_TestData))]
- public void Val_ArgumentException(string value)
+ public void Val_ArgumentException_String(string value)
{
Assert.Throws(() => Conversion.Val(value));
}
@@ -931,7 +931,7 @@ public void Val_InvalidCastException(string value)
[Theory]
[MemberData(nameof(Val_String_OverflowException_TestData))]
- public void Val_OverflowException(string value)
+ public void Val_OverflowException_String(string value)
{
Assert.Throws(() => Conversion.Val(value));
}
diff --git a/src/libraries/Microsoft.VisualBasic.Core/tests/DateAndTimeTests.cs b/src/libraries/Microsoft.VisualBasic.Core/tests/DateAndTimeTests.cs
index d130c7c192adb8..9aa13508f40c19 100644
--- a/src/libraries/Microsoft.VisualBasic.Core/tests/DateAndTimeTests.cs
+++ b/src/libraries/Microsoft.VisualBasic.Core/tests/DateAndTimeTests.cs
@@ -13,14 +13,14 @@ public class DateAndTimeTests
{
[Theory]
[MemberData(nameof(DateAdd_DateInterval_TestData))]
- public void DateAdd(DateInterval interval, double number, DateTime dateValue, DateTime expected)
+ public void DateAdd_DateInterval(DateInterval interval, double number, DateTime dateValue, DateTime expected)
{
Assert.Equal(expected, DateAndTime.DateAdd(interval, number, dateValue));
}
[Theory]
[MemberData(nameof(DateAdd_DateInterval_ArgumentOutOfRangeException_TestData))]
- public void DateAdd_ArgumentOutOfRangeException(DateInterval interval, double number, DateTime dateValue)
+ public void DateAdd_DateInterval_ArgumentOutOfRangeException(DateInterval interval, double number, DateTime dateValue)
{
Assert.Throws(() => DateAndTime.DateAdd(interval, number, dateValue));
}
@@ -125,14 +125,14 @@ public static IEnumerable DateAdd_DateInterval_ArgumentOutOfRangeExcep
[Theory]
[MemberData(nameof(DateAdd_StringInterval_TestData))]
- public void DateAdd(string interval, double number, object dateValue, DateTime expected)
+ public void DateAdd_StringInterval(string interval, double number, object dateValue, DateTime expected)
{
Assert.Equal(expected, DateAndTime.DateAdd(interval, number, dateValue));
}
[Theory]
[MemberData(nameof(DateAdd_StringInterval_ArgumentOutOfRangeException_TestData))]
- public void DateAdd_ArgumentOutOfRangeException(string interval, double number, object dateValue)
+ public void DateAdd_StringInterval_ArgumentOutOfRangeException(string interval, double number, object dateValue)
{
Assert.Throws(() => DateAndTime.DateAdd(interval, number, dateValue));
}
@@ -237,7 +237,7 @@ public static IEnumerable DateAdd_StringInterval_ArgumentOutOfRangeExc
[Theory]
[MemberData(nameof(DateDiff_DateInterval_TestData))]
- public void DateDiff(DateInterval interval, DateTime dateTime1, DateTime dateTime2, long expected)
+ public void DateDiff_DateInterval(DateInterval interval, DateTime dateTime1, DateTime dateTime2, long expected)
{
Assert.Equal(expected, DateAndTime.DateDiff(interval, dateTime1, dateTime2));
}
@@ -277,7 +277,7 @@ public static IEnumerable DateDiff_DateInterval_TestData()
[Theory]
[MemberData(nameof(DateDiff_StringInterval_TestData))]
- public void DateDiff(string interval, object dateTime1, object dateTime2, long expected)
+ public void DateDiff_StringInterval(string interval, object dateTime1, object dateTime2, long expected)
{
Assert.Equal(expected, DateAndTime.DateDiff(interval, dateTime1, dateTime2));
}
@@ -317,7 +317,7 @@ public static IEnumerable DateDiff_StringInterval_TestData()
[Theory]
[MemberData(nameof(DatePart_DateInterval_TestData))]
- public void DatePart(DateInterval interval, DateTime dateValue, int expected)
+ public void DatePart_DateInterval(DateInterval interval, DateTime dateValue, int expected)
{
Assert.Equal(expected, DateAndTime.DatePart(interval, dateValue));
}
@@ -337,7 +337,7 @@ public static IEnumerable DatePart_DateInterval_TestData()
[Theory]
[MemberData(nameof(DatePart_StringInterval_TestData))]
- public void DatePart(string interval, object dateValue, int expected)
+ public void DatePart_StringInterval(string interval, object dateValue, int expected)
{
Assert.Equal(expected, DateAndTime.DatePart(interval, dateValue));
}
diff --git a/src/libraries/Microsoft.VisualBasic.Core/tests/Microsoft/VisualBasic/ComClassAttributeTests.cs b/src/libraries/Microsoft.VisualBasic.Core/tests/Microsoft/VisualBasic/ComClassAttributeTests.cs
index c4310036e08879..e09f402c85fb40 100644
--- a/src/libraries/Microsoft.VisualBasic.Core/tests/Microsoft/VisualBasic/ComClassAttributeTests.cs
+++ b/src/libraries/Microsoft.VisualBasic.Core/tests/Microsoft/VisualBasic/ComClassAttributeTests.cs
@@ -48,7 +48,7 @@ public void Ctor_String_String(string classID, string interfaceID)
[InlineData(null, null, null)]
[InlineData("", "", "")]
[InlineData("classID", "interfaceID", "eventID")]
- public void Ctor_String_String(string classID, string interfaceID, string eventID)
+ public void Ctor_String_String_String(string classID, string interfaceID, string eventID)
{
var attribute = new ComClassAttribute(classID, interfaceID, eventID);
Assert.Equal(classID, attribute.ClassID);
diff --git a/src/libraries/Microsoft.VisualBasic.Core/tests/StringTypeTests.cs b/src/libraries/Microsoft.VisualBasic.Core/tests/StringTypeTests.cs
index 99e4985809b09b..80d69e6a24187d 100644
--- a/src/libraries/Microsoft.VisualBasic.Core/tests/StringTypeTests.cs
+++ b/src/libraries/Microsoft.VisualBasic.Core/tests/StringTypeTests.cs
@@ -51,7 +51,7 @@ public void FromDecimal(decimal value, string expected)
[Theory]
[MemberData(nameof(FromDecimal_Format_TestData))]
- public void FromDecimal(decimal value, NumberFormatInfo format, string expected)
+ public void FromDecimal_Format(decimal value, NumberFormatInfo format, string expected)
{
Assert.Equal(expected, StringType.FromDecimal(value, format));
}
@@ -66,7 +66,7 @@ public void FromDouble(double value, string expected)
[Theory]
[MemberData(nameof(FromDouble_Format_TestData))]
- public void FromDouble(double value, NumberFormatInfo format, string expected)
+ public void FromDouble_Format(double value, NumberFormatInfo format, string expected)
{
Assert.Equal(expected, StringType.FromDouble(value, format));
}
@@ -139,7 +139,7 @@ public void FromSingle(float value, string expected)
[Theory]
[MemberData(nameof(FromSingle_Format_TestData))]
- public void FromSingle(float value, NumberFormatInfo format, string expected)
+ public void FromSingle_Format(float value, NumberFormatInfo format, string expected)
{
Assert.Equal(expected, StringType.FromSingle(value, format));
}
diff --git a/src/libraries/Microsoft.VisualBasic.Core/tests/StringsTests.cs b/src/libraries/Microsoft.VisualBasic.Core/tests/StringsTests.cs
index da8350a036eff9..9800691fb1735a 100644
--- a/src/libraries/Microsoft.VisualBasic.Core/tests/StringsTests.cs
+++ b/src/libraries/Microsoft.VisualBasic.Core/tests/StringsTests.cs
@@ -514,7 +514,7 @@ public void InStrRev_WhenStartZeroOrMinusTwoOrLess_ThrowsArgumentException(int s
[Theory]
[MemberData(nameof(Join_Object_TestData))]
[MemberData(nameof(Join_String_TestData))]
- public void Join(object[] source, string delimiter, string expected)
+ public void Join_ObjectArray(object[] source, string delimiter, string expected)
{
Assert.Equal(expected, Strings.Join(source, delimiter));
}
@@ -531,7 +531,7 @@ public static IEnumerable Join_Object_TestData()
[Theory]
[MemberData(nameof(Join_String_TestData))]
- public void Join(string[] source, string delimiter, string expected)
+ public void Join_StringArray(string[] source, string delimiter, string expected)
{
Assert.Equal(expected, Strings.Join(source, delimiter));
}
@@ -552,7 +552,7 @@ public static IEnumerable Join_String_TestData()
[InlineData('a', 'a')]
[InlineData('A', 'a')]
[InlineData('1', '1')]
- public void LCase(char value, char expected)
+ public void LCase_Char(char value, char expected)
{
Assert.Equal(expected, Strings.LCase(value));
}
@@ -565,7 +565,7 @@ public void LCase(char value, char expected)
[InlineData("abc", "abc")]
[InlineData("ABC", "abc")]
[InlineData("123", "123")]
- public void LCase(string value, string expected)
+ public void LCase_String(string value, string expected)
{
Assert.Equal(expected, Strings.LCase(value));
}
@@ -576,7 +576,7 @@ public void LCase(string value, string expected)
[InlineData('a', 'A')]
[InlineData('A', 'A')]
[InlineData('1', '1')]
- public void UCase(char value, char expected)
+ public void UCase_Char(char value, char expected)
{
Assert.Equal(expected, Strings.UCase(value));
}
@@ -589,7 +589,7 @@ public void UCase(char value, char expected)
[InlineData("abc", "ABC")]
[InlineData("ABC", "ABC")]
[InlineData("123", "123")]
- public void UCase(string value, string expected)
+ public void UCase_String(string value, string expected)
{
Assert.Equal(expected, Strings.UCase(value));
}
@@ -877,42 +877,42 @@ public void StrConv(string str, Microsoft.VisualBasic.VbStrConv conversion, int
[MemberData(nameof(StrDup_Object_TestData))]
[MemberData(nameof(StrDup_Char_TestData))]
[MemberData(nameof(StrDup_String_TestData))]
- public void StrDup(int number, object character, object expected)
+ public void StrDup_Int_Object_Object(int number, object character, object expected)
{
Assert.Equal(expected, Strings.StrDup(number, character));
}
[Theory]
[MemberData(nameof(StrDup_Object_ArgumentException_TestData))]
- public void StrDup_ArgumentException(int number, object character)
+ public void StrDup_ArgumentException_Int_Object(int number, object character)
{
Assert.Throws< ArgumentException>(() => Strings.StrDup(number, character));
}
[Theory]
[MemberData(nameof(StrDup_Char_TestData))]
- public void StrDup(int number, char character, string expected)
+ public void StrDup_Int_Char_String(int number, char character, string expected)
{
Assert.Equal(expected, Strings.StrDup(number, character));
}
[Theory]
[MemberData(nameof(StrDup_Char_ArgumentException_TestData))]
- public void StrDup_ArgumentException(int number, char character)
+ public void StrDup_ArgumentException_Int_Char(int number, char character)
{
Assert.Throws(() => Strings.StrDup(number, character));
}
[Theory]
[MemberData(nameof(StrDup_String_TestData))]
- public void StrDup(int number, string character, string expected)
+ public void StrDup_Int_String_String(int number, string character, string expected)
{
Assert.Equal(expected, Strings.StrDup(number, character));
}
[Theory]
[MemberData(nameof(StrDup_String_ArgumentException_TestData))]
- public void StrDup_ArgumentException(int number, string character)
+ public void StrDup_ArgumentException_Int_String(int number, string character)
{
Assert.Throws(() => Strings.StrDup(number, character));
}
diff --git a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_DeleteSubKeyTree_str.cs b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_DeleteSubKeyTree_str.cs
index c2ccf6dd1e75f4..a43275b9102b80 100644
--- a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_DeleteSubKeyTree_str.cs
+++ b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_DeleteSubKeyTree_str.cs
@@ -92,7 +92,7 @@ public void DeleteSubKeyTree_KeyExists_KeyDeleted(string expected, string subKey
[Theory]
[MemberData(nameof(TestRegistrySubKeyNames))]
- public void Verify_DeleteSubKeyTree_KeyDoesNotExists_Throws(string expected, string subKeyName) =>
+ public void DeleteSubKeyTree_KeyDoesNotExists_Throws(string expected, string subKeyName) =>
Verify_DeleteSubKeyTree_KeyDoesNotExists_Throws(expected, () => TestRegistryKey.DeleteSubKeyTree(subKeyName));
}
}
diff --git a/src/libraries/System.CodeDom/tests/System/CodeDom/CodeMethodInvokeExpressionTests.cs b/src/libraries/System.CodeDom/tests/System/CodeDom/CodeMethodInvokeExpressionTests.cs
index ffa1efd754b328..5a8066201af0aa 100644
--- a/src/libraries/System.CodeDom/tests/System/CodeDom/CodeMethodInvokeExpressionTests.cs
+++ b/src/libraries/System.CodeDom/tests/System/CodeDom/CodeMethodInvokeExpressionTests.cs
@@ -28,7 +28,7 @@ public static IEnumerable Ctor_CodeMethodReferenceExpression_ParamsCod
[Theory]
[MemberData(nameof(Ctor_CodeMethodReferenceExpression_ParamsCodeExpression_TestData))]
- public void Ctor(CodeMethodReferenceExpression method, CodeExpression[] parameters)
+ public void Ctor_Method_Parameters(CodeMethodReferenceExpression method, CodeExpression[] parameters)
{
var methodInvoke = new CodeMethodInvokeExpression(method, parameters);
Assert.Equal((method ?? new CodeMethodReferenceExpression()).TargetObject, methodInvoke.Method.TargetObject);
@@ -45,7 +45,7 @@ public static IEnumerable Ctor_CodeExpression_String_ParamsCodeExpress
[Theory]
[MemberData(nameof(Ctor_CodeExpression_String_ParamsCodeExpression_TestData))]
- public void Ctor(CodeExpression targetObject, string methodName, CodeExpression[] parameters)
+ public void Ctor_TargetObject_MethodName_Parameters(CodeExpression targetObject, string methodName, CodeExpression[] parameters)
{
var methodInvoke = new CodeMethodInvokeExpression(targetObject, methodName, parameters);
Assert.Equal(targetObject, methodInvoke.Method.TargetObject);
diff --git a/src/libraries/System.CodeDom/tests/System/CodeDom/CodeMethodReferenceExpressionTests.cs b/src/libraries/System.CodeDom/tests/System/CodeDom/CodeMethodReferenceExpressionTests.cs
index db9b01442880b5..018acb566ea95f 100644
--- a/src/libraries/System.CodeDom/tests/System/CodeDom/CodeMethodReferenceExpressionTests.cs
+++ b/src/libraries/System.CodeDom/tests/System/CodeDom/CodeMethodReferenceExpressionTests.cs
@@ -28,7 +28,7 @@ public static IEnumerable Ctor_CodeExpression_String_TestData()
[Theory]
[MemberData(nameof(Ctor_CodeExpression_String_TestData))]
- public void Ctor(CodeExpression targetObject, string methodName)
+ public void Ctor_TargetObject_MethodName(CodeExpression targetObject, string methodName)
{
var methodReference = new CodeMethodReferenceExpression(targetObject, methodName);
Assert.Equal(targetObject, methodReference.TargetObject);
@@ -44,7 +44,7 @@ public static IEnumerable Ctor_CodeExpression_String_ParamsCodeExpress
[Theory]
[MemberData(nameof(Ctor_CodeExpression_String_ParamsCodeExpression_TestData))]
- public void Ctor(CodeExpression targetObject, string methodName, CodeTypeReference[] typeArguments)
+ public void Ctor_TargetObject_MethodName_TypeArguments(CodeExpression targetObject, string methodName, CodeTypeReference[] typeArguments)
{
var methodReference = new CodeMethodReferenceExpression(targetObject, methodName, typeArguments);
Assert.Equal(targetObject, methodReference.TargetObject);
diff --git a/src/libraries/System.CodeDom/tests/System/CodeDom/CodeObjectCreateExpressionTests.cs b/src/libraries/System.CodeDom/tests/System/CodeDom/CodeObjectCreateExpressionTests.cs
index 8a7a160846c7b7..bd2cc7163bdf3f 100644
--- a/src/libraries/System.CodeDom/tests/System/CodeDom/CodeObjectCreateExpressionTests.cs
+++ b/src/libraries/System.CodeDom/tests/System/CodeDom/CodeObjectCreateExpressionTests.cs
@@ -27,7 +27,7 @@ public static IEnumerable Ctor_CodeTypeReference_ParamsCodeExpression_
[Theory]
[MemberData(nameof(Ctor_CodeTypeReference_ParamsCodeExpression_TestData))]
- public void Ctor(CodeTypeReference type, CodeExpression[] parameters)
+ public void Ctor_Type_Parameters(CodeTypeReference type, CodeExpression[] parameters)
{
var objectCreate = new CodeObjectCreateExpression(type, parameters);
Assert.Equal((type ?? new CodeTypeReference("")).BaseType, objectCreate.CreateType.BaseType);
@@ -43,7 +43,7 @@ public static IEnumerable Ctor_String_ParamsCodeExpression_TestData()
[Theory]
[MemberData(nameof(Ctor_String_ParamsCodeExpression_TestData))]
- public void Ctor(string type, CodeExpression[] parameters, string expectedBaseType)
+ public void Ctor_Type_Parameters_ExpectedBaseType(string type, CodeExpression[] parameters, string expectedBaseType)
{
var objectCreate = new CodeObjectCreateExpression(type, parameters);
Assert.Equal(expectedBaseType, objectCreate.CreateType.BaseType);
diff --git a/src/libraries/System.Collections.Concurrent/tests/ConcurrentDictionary/ConcurrentDictionaryTests.cs b/src/libraries/System.Collections.Concurrent/tests/ConcurrentDictionary/ConcurrentDictionaryTests.cs
index d2a770f26a310d..374f93a6ba645e 100644
--- a/src/libraries/System.Collections.Concurrent/tests/ConcurrentDictionary/ConcurrentDictionaryTests.cs
+++ b/src/libraries/System.Collections.Concurrent/tests/ConcurrentDictionary/ConcurrentDictionaryTests.cs
@@ -124,20 +124,16 @@ public static void TestAddValueOfDifferentType()
Assert.Throws(action);
}
- [Fact]
- public static void TestAdd1()
- {
- TestAdd1(1, 1, 1, 10000);
- TestAdd1(5, 1, 1, 10000);
- TestAdd1(1, 1, 2, 5000);
- TestAdd1(1, 1, 5, 2000);
- TestAdd1(4, 0, 4, 2000);
- TestAdd1(16, 31, 4, 2000);
- TestAdd1(64, 5, 5, 5000);
- TestAdd1(5, 5, 5, 2500);
- }
-
- private static void TestAdd1(int cLevel, int initSize, int threads, int addsPerThread)
+ [Theory]
+ [InlineData(1, 1, 1, 10000)]
+ [InlineData(5, 1, 1, 10000)]
+ [InlineData(1, 1, 2, 5000)]
+ [InlineData(1, 1, 5, 2000)]
+ [InlineData(4, 0, 4, 2000)]
+ [InlineData(16, 31, 4, 2000)]
+ [InlineData(64, 5, 5, 5000)]
+ [InlineData(5, 5, 5, 2500)]
+ public static void TestAdd(int cLevel, int initSize, int threads, int addsPerThread)
{
ConcurrentDictionary dictConcurrent = new ConcurrentDictionary(cLevel, 1);
IDictionary dict = dictConcurrent;
@@ -193,20 +189,16 @@ private static void TestAdd1(int cLevel, int initSize, int threads, int addsPerT
Assert.Equal(expectedCount, dictConcurrent.ToArray().Length);
}
- [Fact]
- public static void TestUpdate1()
- {
- TestUpdate1(1, 1, 10000);
- TestUpdate1(5, 1, 10000);
- TestUpdate1(1, 2, 5000);
- TestUpdate1(1, 5, 2001);
- TestUpdate1(4, 4, 2001);
- TestUpdate1(15, 5, 2001);
- TestUpdate1(64, 5, 5000);
- TestUpdate1(5, 5, 25000);
- }
-
- private static void TestUpdate1(int cLevel, int threads, int updatesPerThread)
+ [Theory]
+ [InlineData(1, 1, 10000)]
+ [InlineData(5, 1, 10000)]
+ [InlineData(1, 2, 5000)]
+ [InlineData(1, 5, 2001)]
+ [InlineData(4, 4, 2001)]
+ [InlineData(15, 5, 2001)]
+ [InlineData(64, 5, 5000)]
+ [InlineData(5, 5, 25000)]
+ public static void TestUpdate(int cLevel, int threads, int updatesPerThread)
{
IDictionary dict = new ConcurrentDictionary(cLevel, 1);
@@ -261,20 +253,16 @@ private static void TestUpdate1(int cLevel, int threads, int updatesPerThread)
}
}
- [Fact]
- public static void TestRead1()
- {
- TestRead1(1, 1, 10000);
- TestRead1(5, 1, 10000);
- TestRead1(1, 2, 5000);
- TestRead1(1, 5, 2001);
- TestRead1(4, 4, 2001);
- TestRead1(15, 5, 2001);
- TestRead1(64, 5, 5000);
- TestRead1(5, 5, 25000);
- }
-
- private static void TestRead1(int cLevel, int threads, int readsPerThread)
+ [Theory]
+ [InlineData(1, 1, 10000)]
+ [InlineData(5, 1, 10000)]
+ [InlineData(1, 2, 5000)]
+ [InlineData(1, 5, 2001)]
+ [InlineData(4, 4, 2001)]
+ [InlineData(15, 5, 2001)]
+ [InlineData(64, 5, 5000)]
+ [InlineData(5, 5, 25000)]
+ public static void TestRead1(int cLevel, int threads, int readsPerThread)
{
IDictionary dict = new ConcurrentDictionary(cLevel, 1);
@@ -309,18 +297,14 @@ private static void TestRead1(int cLevel, int threads, int readsPerThread)
}
}
- [Fact]
- public static void TestRemove1()
- {
- TestRemove1(1, 1, 10000);
- TestRemove1(5, 1, 1000);
- TestRemove1(1, 5, 2001);
- TestRemove1(4, 4, 2001);
- TestRemove1(15, 5, 2001);
- TestRemove1(64, 5, 5000);
- }
-
- private static void TestRemove1(int cLevel, int threads, int removesPerThread)
+ [Theory]
+ [InlineData(1, 1, 10000)]
+ [InlineData(5, 1, 1000)]
+ [InlineData(1, 5, 2001)]
+ [InlineData(4, 4, 2001)]
+ [InlineData(15, 5, 2001)]
+ [InlineData(64, 5, 5000)]
+ public static void TestRemove1(int cLevel, int threads, int removesPerThread)
{
ConcurrentDictionary dict = new ConcurrentDictionary(cLevel, 1);
string methodparameters = string.Format("* TestRemove1(cLevel={0}, threads={1}, removesPerThread={2})", cLevel, threads, removesPerThread);
@@ -381,15 +365,11 @@ private static void TestRemove1(int cLevel, int threads, int removesPerThread)
Assert.Equal(expectKeys.Count, dict.ToArray().Length);
}
- [Fact]
- public static void TestRemove2()
- {
- TestRemove2(1);
- TestRemove2(10);
- TestRemove2(5000);
- }
-
- private static void TestRemove2(int removesPerThread)
+ [Theory]
+ [InlineData(1)]
+ [InlineData(10)]
+ [InlineData(5000)]
+ public static void TestRemove2(int removesPerThread)
{
ConcurrentDictionary dict = new ConcurrentDictionary();
diff --git a/src/libraries/System.Collections.Concurrent/tests/IntRangePartitionerTests.cs b/src/libraries/System.Collections.Concurrent/tests/IntRangePartitionerTests.cs
index 3680f2fded80e0..b6116cc71e5f9a 100644
--- a/src/libraries/System.Collections.Concurrent/tests/IntRangePartitionerTests.cs
+++ b/src/libraries/System.Collections.Concurrent/tests/IntRangePartitionerTests.cs
@@ -49,17 +49,13 @@ public static void CheckKeyProperties()
/// We unroll the tuples and flatten them to a single sequence
/// The single sequence is compared to the original range for verification
///
- [Fact]
- public static void CheckGetPartitions()
- {
- CheckGetPartitions(0, 1, 1);
- CheckGetPartitions(1, 1999, 3);
- CheckGetPartitions(2147473647, 9999, 4);
- CheckGetPartitions(-1999, 5000, 63);
- CheckGetPartitions(-2147483648, 5000, 63);
- }
-
- private static void CheckGetPartitions(int from, int count, int dop)
+ [Theory]
+ [InlineData(0, 1, 1)]
+ [InlineData(1, 1999, 3)]
+ [InlineData(2147473647, 9999, 4)]
+ [InlineData(-1999, 5000, 63)]
+ [InlineData(-2147483648, 5000, 63)]
+ public static void CheckGetPartitions(int from, int count, int dop)
{
int to = from + count;
var partitioner = Partitioner.Create(from, to);
@@ -82,17 +78,13 @@ private static void CheckGetPartitions(int from, int count, int dop)
///
///
///
- [Fact]
- public static void CheckGetDynamicPartitions()
- {
- CheckGetDynamicPartitions(0, 1);
- CheckGetDynamicPartitions(1, 1999);
- CheckGetDynamicPartitions(2147473647, 9999);
- CheckGetDynamicPartitions(-1999, 5000);
- CheckGetDynamicPartitions(-2147483648, 5000);
- }
-
- private static void CheckGetDynamicPartitions(int from, int count)
+ [Theory]
+ [InlineData(0, 1)]
+ [InlineData(1, 1999)]
+ [InlineData(2147473647, 9999)]
+ [InlineData(-1999, 5000)]
+ [InlineData(-2147483648, 5000)]
+ public static void CheckGetDynamicPartitions(int from, int count)
{
int to = from + count;
var partitioner = Partitioner.Create(from, to);
@@ -114,17 +106,13 @@ private static void CheckGetDynamicPartitions(int from, int count)
/// The single sequence is compared to the original range for verification
/// Also the indices are extracted to ensure that they are ordered & normalized
///
- [Fact]
- public static void CheckGetOrderablePartitions()
- {
- CheckGetOrderablePartitions(0, 1, 1);
- CheckGetOrderablePartitions(1, 1999, 3);
- CheckGetOrderablePartitions(2147473647, 9999, 4);
- CheckGetOrderablePartitions(-1999, 5000, 63);
- CheckGetOrderablePartitions(-2147483648, 5000, 63);
- }
-
- private static void CheckGetOrderablePartitions(int from, int count, int dop)
+ [Theory]
+ [InlineData(0, 1, 1)]
+ [InlineData(1, 1999, 3)]
+ [InlineData(2147473647, 9999, 4)]
+ [InlineData(-1999, 5000, 63)]
+ [InlineData(-2147483648, 5000, 63)]
+ public static void CheckGetOrderablePartitions(int from, int count, int dop)
{
int to = from + count;
var partitioner = Partitioner.Create(from, to);
@@ -155,17 +143,13 @@ private static void CheckGetOrderablePartitions(int from, int count, int dop)
/// The single sequence is compared to the original range for verification
/// Also the indices are extracted to ensure that they are ordered & normalized
///
- [Fact]
- public static void GetOrderableDynamicPartitions()
- {
- GetOrderableDynamicPartitions(0, 1);
- GetOrderableDynamicPartitions(1, 1999);
- GetOrderableDynamicPartitions(2147473647, 9999);
- GetOrderableDynamicPartitions(-1999, 5000);
- GetOrderableDynamicPartitions(-2147483648, 5000);
- }
-
- private static void GetOrderableDynamicPartitions(int from, int count)
+ [Theory]
+ [InlineData(0, 1)]
+ [InlineData(1, 1999)]
+ [InlineData(2147473647, 9999)]
+ [InlineData(-1999, 5000)]
+ [InlineData(-2147483648, 5000)]
+ public static void GetOrderableDynamicPartitions(int from, int count)
{
int to = from + count;
var partitioner = Partitioner.Create(from, to);
@@ -197,17 +181,13 @@ private static void GetOrderableDynamicPartitions(int from, int count)
/// The range sizes for individual ranges are checked to see if they are equal to
/// desiredRangeSize. The last range may have less than or equal to desiredRangeSize.
///
- [Fact]
- public static void CheckGetPartitionsWithRange()
- {
- CheckGetPartitionsWithRange(1999, 1000, 20, 1);
- CheckGetPartitionsWithRange(-1999, 1000, 100, 2);
- CheckGetPartitionsWithRange(1999, 1, 2000, 3);
- CheckGetPartitionsWithRange(2147482647, 999, 600, 4);
- CheckGetPartitionsWithRange(-2147483648, 1000, 19, 63);
- }
-
- private static void CheckGetPartitionsWithRange(int from, int count, int desiredRangeSize, int dop)
+ [Theory]
+ [InlineData(1999, 1000, 20, 1)]
+ [InlineData(-1999, 1000, 100, 2)]
+ [InlineData(1999, 1, 2000, 3)]
+ [InlineData(2147482647, 999, 600, 4)]
+ [InlineData(-2147483648, 1000, 19, 63)]
+ public static void CheckGetPartitionsWithRange(int from, int count, int desiredRangeSize, int dop)
{
int to = from + count;
var partitioner = Partitioner.Create(from, to, desiredRangeSize);
@@ -240,17 +220,13 @@ private static void CheckGetPartitionsWithRange(int from, int count, int desired
/// The range sizes for individual ranges are checked to see if they are equal to
/// desiredRangeSize. The last range may have less than or equal to desiredRangeSize.
///
- [Fact]
- public static void CheckGetDynamicPartitionsWithRange()
- {
- CheckGetDynamicPartitionsWithRange(1999, 1000, 20);
- CheckGetDynamicPartitionsWithRange(-1999, 1000, 100);
- CheckGetDynamicPartitionsWithRange(1999, 1, 2000);
- CheckGetDynamicPartitionsWithRange(2147482647, 999, 600);
- CheckGetDynamicPartitionsWithRange(-2147483648, 1000, 19);
- }
-
- private static void CheckGetDynamicPartitionsWithRange(int from, int count, int desiredRangeSize)
+ [Theory]
+ [InlineData(1999, 1000, 20)]
+ [InlineData(-1999, 1000, 100)]
+ [InlineData(1999, 1, 2000)]
+ [InlineData(2147482647, 999, 600)]
+ [InlineData(-2147483648, 1000, 19)]
+ public static void CheckGetDynamicPartitionsWithRange(int from, int count, int desiredRangeSize)
{
int to = from + count;
var partitioner = Partitioner.Create(from, to, desiredRangeSize);
@@ -284,17 +260,13 @@ private static void CheckGetDynamicPartitionsWithRange(int from, int count, int
/// The range sizes for individual ranges are checked to see if they are equal to
/// desiredRangeSize. The last range may have less than or equal to desiredRangeSize.
///
- [Fact]
- public static void CheckGetOrderablePartitionsWithRange()
- {
- CheckGetOrderablePartitionsWithRange(1999, 1000, 20, 1);
- CheckGetOrderablePartitionsWithRange(-1999, 1000, 100, 2);
- CheckGetOrderablePartitionsWithRange(1999, 1, 2000, 3);
- CheckGetOrderablePartitionsWithRange(2147482647, 999, 600, 4);
- CheckGetOrderablePartitionsWithRange(-2147483648, 1000, 19, 63);
- }
-
- private static void CheckGetOrderablePartitionsWithRange(int from, int count, int desiredRangeSize, int dop)
+ [Theory]
+ [InlineData(1999, 1000, 20, 1)]
+ [InlineData(-1999, 1000, 100, 2)]
+ [InlineData(1999, 1, 2000, 3)]
+ [InlineData(2147482647, 999, 600, 4)]
+ [InlineData(-2147483648, 1000, 19, 63)]
+ public static void CheckGetOrderablePartitionsWithRange(int from, int count, int desiredRangeSize, int dop)
{
int to = from + count;
var partitioner = Partitioner.Create(from, to, desiredRangeSize);
@@ -337,17 +309,13 @@ private static void CheckGetOrderablePartitionsWithRange(int from, int count, in
/// The range sizes for individual ranges are checked to see if they are equal to
/// desiredRangeSize. The last range may have less than or equal to desiredRangeSize.
///
- [Fact]
- public static void GetOrderableDynamicPartitionsWithRange()
- {
- GetOrderableDynamicPartitionsWithRange(1999, 1000, 20);
- GetOrderableDynamicPartitionsWithRange(-1999, 1000, 100);
- GetOrderableDynamicPartitionsWithRange(1999, 1, 2000);
- GetOrderableDynamicPartitionsWithRange(2147482647, 999, 600);
- GetOrderableDynamicPartitionsWithRange(-2147483648, 1000, 19);
- }
-
- private static void GetOrderableDynamicPartitionsWithRange(int from, int count, int desiredRangeSize)
+ [Theory]
+ [InlineData(1999, 1000, 20)]
+ [InlineData(-1999, 1000, 100)]
+ [InlineData(1999, 1, 2000)]
+ [InlineData(2147482647, 999, 600)]
+ [InlineData(-2147483648, 1000, 19)]
+ public static void GetOrderableDynamicPartitionsWithRange(int from, int count, int desiredRangeSize)
{
int to = from + count;
var partitioner = Partitioner.Create(from, to, desiredRangeSize);
@@ -400,20 +368,16 @@ private static void ValidateRangeSize(int desiredRangeSize, IList rangeSize
Assert.InRange(rangeSizes[rangeSizes.Count - 1], 0, desiredRangeSize);
}
- [Fact]
- public static void RangePartitionerChunking()
- {
- RangePartitionerChunking(1999, 1000, 10);
- RangePartitionerChunking(89, 17823, -1);
- }
-
///
/// Ensure that the range partitioner doesn't chunk up elements i.e. uses chunk size = 1
///
///
///
///
- private static void RangePartitionerChunking(int from, int count, int rangeSize)
+ [Theory]
+ [InlineData(1999, 1000, 10)]
+ [InlineData(89, 17823, -1)]
+ public static void RangePartitionerChunking(int from, int count, int rangeSize)
{
int to = from + count;
@@ -480,20 +444,16 @@ private static void RangePartitionerChunking(int from, int count, int rangeSize)
Assert.Equal(count, actualCount);
}
- [Fact]
- public static void RangePartitionerDynamicChunking()
- {
- RangePartitionerDynamicChunking(1999, 1000, 10);
- RangePartitionerDynamicChunking(1, 884354, -1);
- }
-
///
/// Ensure that the range partitioner doesn't chunk up elements i.e. uses chunk size = 1
///
///
///
///
- private static void RangePartitionerDynamicChunking(int from, int count, int rangeSize)
+ [Theory]
+ [InlineData(1999, 1000, 10)]
+ [InlineData(1, 884354, -1)]
+ public static void RangePartitionerDynamicChunking(int from, int count, int rangeSize)
{
int to = from + count;
@@ -557,7 +517,7 @@ private static void RangePartitionerDynamicChunking(int from, int count, int ran
// Verifying that all items are there
Assert.Equal(count, actualCount);
}
-
+
///
/// Ensure that the range partitioner doesn't exceed the exclusive bound
///
diff --git a/src/libraries/System.Collections.Concurrent/tests/LongRangePartitionerTests.cs b/src/libraries/System.Collections.Concurrent/tests/LongRangePartitionerTests.cs
index 98b4ecc9aec8cb..dbb2909b52ff6d 100644
--- a/src/libraries/System.Collections.Concurrent/tests/LongRangePartitionerTests.cs
+++ b/src/libraries/System.Collections.Concurrent/tests/LongRangePartitionerTests.cs
@@ -49,19 +49,15 @@ public static void CheckKeyProperties()
/// We unroll the tuples and flatten them to a single sequence
/// The single sequence is compared to the original range for verification
///
- [Fact]
- public static void CheckGetPartitions()
- {
- CheckGetPartitions(0, 1, 1);
- CheckGetPartitions(1, 1999, 3);
- CheckGetPartitions(2147473647, 9999, 4);
- CheckGetPartitions(2147484647, 1000, 8);
- CheckGetPartitions(-2147484647, 1000, 16);
- CheckGetPartitions(-1999, 5000, 63);
- CheckGetPartitions(9223372036854774807, 999, 13); // close to Int64.Max
- }
-
- private static void CheckGetPartitions(long from, long count, int dop)
+ [Theory]
+ [InlineData(0, 1, 1)]
+ [InlineData(1, 1999, 3)]
+ [InlineData(2147473647, 9999, 4)]
+ [InlineData(2147484647, 1000, 8)]
+ [InlineData(-2147484647, 1000, 16)]
+ [InlineData(-1999, 5000, 63)]
+ [InlineData(9223372036854774807, 999, 13)] // close to Int64.Max
+ public static void CheckGetPartitions(long from, long count, int dop)
{
long to = from + count;
var partitioner = Partitioner.Create(from, to);
@@ -81,19 +77,15 @@ private static void CheckGetPartitions(long from, long count, int dop)
/// We unroll the tuples and flatten them to a single sequence
/// The single sequence is compared to the original range for verification
///
- [Fact]
- public static void CheckGetDynamicPartitions()
- {
- CheckGetDynamicPartitions(0, 1);
- CheckGetDynamicPartitions(1, 1999);
- CheckGetDynamicPartitions(2147473647, 9999);
- CheckGetDynamicPartitions(2147484647, 1000);
- CheckGetDynamicPartitions(-2147484647, 1000);
- CheckGetDynamicPartitions(-1999, 5000);
- CheckGetDynamicPartitions(9223372036854774807, 999); // close to Int64.Max
- }
-
- private static void CheckGetDynamicPartitions(long from, long count)
+ [Theory]
+ [InlineData(0, 1)]
+ [InlineData(1, 1999)]
+ [InlineData(2147473647, 9999)]
+ [InlineData(2147484647, 1000)]
+ [InlineData(-2147484647, 1000)]
+ [InlineData(-1999, 5000)]
+ [InlineData(9223372036854774807, 999)] // close to Int64.Max
+ public static void CheckGetDynamicPartitions(long from, long count)
{
long to = from + count;
var partitioner = Partitioner.Create(from, to);
@@ -114,19 +106,15 @@ private static void CheckGetDynamicPartitions(long from, long count)
/// The single sequence is compared to the original range for verification
/// Also the indices are extracted to ensure that they are ordered & normalized
///
- [Fact]
- public static void CheckGetOrderablePartitions()
- {
- CheckGetOrderablePartitions(0, 1, 1);
- CheckGetOrderablePartitions(1, 1999, 3);
- CheckGetOrderablePartitions(2147473647, 9999, 4);
- CheckGetOrderablePartitions(2147484647, 1000, 8);
- CheckGetOrderablePartitions(-2147484647, 1000, 16);
- CheckGetOrderablePartitions(-1999, 5000, 63);
- CheckGetOrderablePartitions(9223372036854774807, 999, 13); // close to Int64.Max
- }
-
- private static void CheckGetOrderablePartitions(long from, long count, int dop)
+ [Theory]
+ [InlineData(0, 1, 1)]
+ [InlineData(1, 1999, 3)]
+ [InlineData(2147473647, 9999, 4)]
+ [InlineData(2147484647, 1000, 8)]
+ [InlineData(-2147484647, 1000, 16)]
+ [InlineData(-1999, 5000, 63)]
+ [InlineData(9223372036854774807, 999, 13)] // close to Int64.Max
+ public static void CheckGetOrderablePartitions(long from, long count, int dop)
{
long to = from + count;
var partitioner = Partitioner.Create(from, to);
@@ -159,19 +147,15 @@ private static void CheckGetOrderablePartitions(long from, long count, int dop)
///
///
///
- [Fact]
- public static void GetOrderableDynamicPartitions()
- {
- GetOrderableDynamicPartitions(0, 1);
- GetOrderableDynamicPartitions(1, 1999);
- GetOrderableDynamicPartitions(2147473647, 9999);
- GetOrderableDynamicPartitions(2147484647, 1000);
- GetOrderableDynamicPartitions(-2147484647, 1000);
- GetOrderableDynamicPartitions(-1999, 5000);
- GetOrderableDynamicPartitions(9223372036854774807, 999); // close to Int64.Max
- }
-
- private static void GetOrderableDynamicPartitions(long from, long count)
+ [Theory]
+ [InlineData(0, 1)]
+ [InlineData(1, 1999)]
+ [InlineData(2147473647, 9999)]
+ [InlineData(2147484647, 1000)]
+ [InlineData(-2147484647, 1000)]
+ [InlineData(-1999, 5000)]
+ [InlineData(9223372036854774807, 999)] // close to Int64.Max
+ public static void GetOrderableDynamicPartitions(long from, long count)
{
long to = from + count;
var partitioner = Partitioner.Create(from, to);
@@ -202,17 +186,13 @@ private static void GetOrderableDynamicPartitions(long from, long count)
/// The range sizes for individual ranges are checked to see if they are equal to
/// desiredRangeSize. The last range may have less than or equal to desiredRangeSize.
///
- [Fact]
- public static void CheckGetPartitionsWithRange()
- {
- CheckGetPartitionsWithRange(1999, 1000, 20, 1);
- CheckGetPartitionsWithRange(-1999, 1000, 100, 2);
- CheckGetPartitionsWithRange(1999, 1, 2000, 3);
- CheckGetPartitionsWithRange(9223372036854774807, 999, 600, 4);
- CheckGetPartitionsWithRange(-9223372036854774807, 1000, 19, 63);
- }
-
- private static void CheckGetPartitionsWithRange(long from, long count, long desiredRangeSize, int dop)
+ [Theory]
+ [InlineData(1999, 1000, 20, 1)]
+ [InlineData(-1999, 1000, 100, 2)]
+ [InlineData(1999, 1, 2000, 3)]
+ [InlineData(9223372036854774807, 999, 600, 4)]
+ [InlineData(-9223372036854774807, 1000, 19, 63)]
+ public static void CheckGetPartitionsWithRange(long from, long count, long desiredRangeSize, int dop)
{
long to = from + count;
var partitioner = Partitioner.Create(from, to, desiredRangeSize);
@@ -244,17 +224,13 @@ private static void CheckGetPartitionsWithRange(long from, long count, long desi
/// The range sizes for individual ranges are checked to see if they are equal to
/// desiredRangeSize. The last range may have less than or equal to desiredRangeSize.
///
- [Fact]
- public static void CheckGetDynamicPartitionsWithRange()
- {
- CheckGetDynamicPartitionsWithRange(1999, 1000, 20);
- CheckGetDynamicPartitionsWithRange(-1999, 1000, 100);
- CheckGetDynamicPartitionsWithRange(1999, 1, 2000);
- CheckGetDynamicPartitionsWithRange(9223372036854774807, 999, 600);
- CheckGetDynamicPartitionsWithRange(-9223372036854774807, 1000, 19);
- }
-
- private static void CheckGetDynamicPartitionsWithRange(long from, long count, long desiredRangeSize)
+ [Theory]
+ [InlineData(1999, 1000, 20)]
+ [InlineData(-1999, 1000, 100)]
+ [InlineData(1999, 1, 2000)]
+ [InlineData(9223372036854774807, 999, 600)]
+ [InlineData(-9223372036854774807, 1000, 19)]
+ public static void CheckGetDynamicPartitionsWithRange(long from, long count, long desiredRangeSize)
{
long to = from + count;
var partitioner = Partitioner.Create(from, to, desiredRangeSize);
@@ -286,17 +262,13 @@ private static void CheckGetDynamicPartitionsWithRange(long from, long count, lo
/// The range sizes for individual ranges are checked to see if they are equal to
/// desiredRangeSize. The last range may have less than or equal to desiredRangeSize.
///
- [Fact]
- public static void CheckGetOrderablePartitionsWithRange()
- {
- CheckGetOrderablePartitionsWithRange(1999, 1000, 20, 1);
- CheckGetOrderablePartitionsWithRange(-1999, 1000, 100, 2);
- CheckGetOrderablePartitionsWithRange(1999, 1, 2000, 3);
- CheckGetOrderablePartitionsWithRange(9223372036854774807, 999, 600, 4);
- CheckGetOrderablePartitionsWithRange(-9223372036854774807, 1000, 19, 63);
- }
-
- private static void CheckGetOrderablePartitionsWithRange(long from, long count, long desiredRangeSize, int dop)
+ [Theory]
+ [InlineData(1999, 1000, 20, 1)]
+ [InlineData(-1999, 1000, 100, 2)]
+ [InlineData(1999, 1, 2000, 3)]
+ [InlineData(9223372036854774807, 999, 600, 4)]
+ [InlineData(-9223372036854774807, 1000, 19, 63)]
+ public static void CheckGetOrderablePartitionsWithRange(long from, long count, long desiredRangeSize, int dop)
{
long to = from + count;
var partitioner = Partitioner.Create(from, to, desiredRangeSize);
@@ -339,17 +311,13 @@ private static void CheckGetOrderablePartitionsWithRange(long from, long count,
/// The range sizes for individual ranges are checked to see if they are equal to
/// desiredRangeSize. The last range may have less than or equal to desiredRangeSize.
///
- [Fact]
- public static void GetOrderableDynamicPartitionsWithRange()
- {
- GetOrderableDynamicPartitionsWithRange(1999, 1000, 20);
- GetOrderableDynamicPartitionsWithRange(-1999, 1000, 100);
- GetOrderableDynamicPartitionsWithRange(1999, 1, 2000);
- GetOrderableDynamicPartitionsWithRange(9223372036854774807, 999, 600);
- GetOrderableDynamicPartitionsWithRange(-9223372036854774807, 1000, 19);
- }
-
- private static void GetOrderableDynamicPartitionsWithRange(long from, long count, long desiredRangeSize)
+ [Theory]
+ [InlineData(1999, 1000, 20)]
+ [InlineData(-1999, 1000, 100)]
+ [InlineData(1999, 1, 2000)]
+ [InlineData(9223372036854774807, 999, 600)]
+ [InlineData(-9223372036854774807, 1000, 19)]
+ public static void GetOrderableDynamicPartitionsWithRange(long from, long count, long desiredRangeSize)
{
long to = from + count;
var partitioner = Partitioner.Create(from, to, desiredRangeSize);
@@ -408,14 +376,10 @@ private static void ValidateRangeSize(long desiredRangeSize, IList rangeSi
///
/// Ensure that the range partitioner doesn't chunk up elements i.e. uses chunk size = 1
///
- [Fact]
- public static void RangePartitionerChunking()
- {
- RangePartitionerChunking(2147473647, 9999, 4);
- RangePartitionerChunking(2147484647, 1000, -1);
- }
-
- private static void RangePartitionerChunking(long from, long count, long rangeSize)
+ [Theory]
+ [InlineData(2147473647, 9999, 4)]
+ [InlineData(2147484647, 1000, -1)]
+ public static void RangePartitionerChunking(long from, long count, long rangeSize)
{
long to = from + count;
@@ -481,14 +445,10 @@ private static void RangePartitionerChunking(long from, long count, long rangeSi
///
/// Ensure that the range partitioner doesn't chunk up elements i.e. uses chunk size = 1
///
- [Fact]
- public static void RangePartitionerDynamicChunking()
- {
- RangePartitionerDynamicChunking(2147473647, 9999, 4);
- RangePartitionerDynamicChunking(2147484647, 1000, -1);
- }
-
- private static void RangePartitionerDynamicChunking(long from, long count, long rangeSize)
+ [Theory]
+ [InlineData(2147473647, 9999, 4)]
+ [InlineData(2147484647, 1000, -1)]
+ public static void RangePartitionerDynamicChunking(long from, long count, long rangeSize)
{
long to = from + count;
@@ -552,7 +512,7 @@ private static void RangePartitionerDynamicChunking(long from, long count, long
// Verifying that all items are there
Assert.Equal(count, actualCount);
}
-
+
///
/// Ensure that the range partitioner doesn't exceed the exclusive bound
///
diff --git a/src/libraries/System.Collections.Concurrent/tests/RangePartitionerNegativeTests.cs b/src/libraries/System.Collections.Concurrent/tests/RangePartitionerNegativeTests.cs
index 0a0fa4eed58768..c3795c8d9a9a63 100644
--- a/src/libraries/System.Collections.Concurrent/tests/RangePartitionerNegativeTests.cs
+++ b/src/libraries/System.Collections.Concurrent/tests/RangePartitionerNegativeTests.cs
@@ -25,15 +25,11 @@ public class RangePartitionerNegativeTests
///
/// Test passing invalid range, 'to' is smaller or equal than 'from'
///
- [Fact]
- public static void IntFromNotGreaterThanTo()
- {
- IntFromNotGreaterThanTo(1000, 0, 100);
- IntFromNotGreaterThanTo(899, 899, 100);
- IntFromNotGreaterThanTo(-19999, -299999, 100);
- }
-
- private static void IntFromNotGreaterThanTo(int from, int to, int rangesize)
+ [Theory]
+ [InlineData(1000, 0, 100)]
+ [InlineData(899, 899, 100)]
+ [InlineData(-19999, -299999, 100)]
+ public static void IntFromNotGreaterThanTo(int from, int to, int rangesize)
{
Assert.Throws(() => Partitioner.Create(from, to));
Assert.Throws(() => Partitioner.Create(from, to, rangesize));
@@ -41,15 +37,11 @@ private static void IntFromNotGreaterThanTo(int from, int to, int rangesize)
///
/// Test passing invalid range, 'to' is smaller or equal than 'from', on long overload
- [Fact]
- public static void LongFromNotGreaterThanTo()
- {
- LongFromNotGreaterThanTo(1000, 0, 100);
- LongFromNotGreaterThanTo(899, 899, 100);
- LongFromNotGreaterThanTo(-19999, -299999, 100);
- }
-
- private static void LongFromNotGreaterThanTo(long from, long to, int rangesize)
+ [Theory]
+ [InlineData(1000, 0, 100)]
+ [InlineData(899, 899, 100)]
+ [InlineData(-19999, -299999, 100)]
+ public static void LongFromNotGreaterThanTo(long from, long to, int rangesize)
{
Assert.Throws(() => Partitioner.Create(from, to));
Assert.Throws(() => Partitioner.Create(from, to, rangesize));
@@ -58,14 +50,10 @@ private static void LongFromNotGreaterThanTo(long from, long to, int rangesize)
///
/// Test passing invalid range size, less than or equal to 0
///
- [Fact]
- public static void InvalidIntRangeSize()
- {
- InvalidIntRangeSize(0, 1000, 0);
- InvalidIntRangeSize(899, 9000, -10);
- }
-
- private static void InvalidIntRangeSize(int from, int to, int rangesize)
+ [Theory]
+ [InlineData(0, 1000, 0)]
+ [InlineData(899, 9000, -10)]
+ public static void InvalidIntRangeSize(int from, int to, int rangesize)
{
Assert.Throws(() => Partitioner.Create(from, to, rangesize));
}
@@ -73,14 +61,10 @@ private static void InvalidIntRangeSize(int from, int to, int rangesize)
///
/// Test passing invalid range size, less than or equal to 0, on long overload
///
- [Fact]
- public static void ATestMethod()
- {
- InvalidLongRangeSize(0, 1000, 0);
- InvalidLongRangeSize(899, 9000, -10);
- }
-
- private static void InvalidLongRangeSize(long from, long to, long rangesize)
+ [Theory]
+ [InlineData(0, 1000, 0)]
+ [InlineData(899, 9000, -10)]
+ public static void InvalidLongRangeSize(long from, long to, long rangesize)
{
Assert.Throws(() => Partitioner.Create(from, to, rangesize));
}
diff --git a/src/libraries/System.Collections.Immutable/tests/ImmutableArrayTest.cs b/src/libraries/System.Collections.Immutable/tests/ImmutableArrayTest.cs
index a1bc3d7db8805a..192b779249efb2 100644
--- a/src/libraries/System.Collections.Immutable/tests/ImmutableArrayTest.cs
+++ b/src/libraries/System.Collections.Immutable/tests/ImmutableArrayTest.cs
@@ -838,7 +838,7 @@ public static IEnumerable EnumeratorTraversalNullData()
[Theory]
[MemberData(nameof(EqualsData))]
- public void Equals(ImmutableArray first, ImmutableArray second, bool expected)
+ public void EqualsTest(ImmutableArray first, ImmutableArray second, bool expected)
{
Assert.Equal(expected, first == second);
Assert.NotEqual(expected, first != second);
@@ -944,7 +944,7 @@ public void EqualsNullable(IEnumerable source)
[Theory]
[MemberData(nameof(Int32EnumerableData))]
[MemberData(nameof(SpecialInt32ImmutableArrayData))]
- public void GetHashCode(IEnumerable source)
+ public void GetHashCodeTest(IEnumerable source)
{
var array = source.ToImmutableArray();
@@ -2252,7 +2252,7 @@ public void AddThreadSafety()
[Theory]
[MemberData(nameof(Int32EnumerableData))]
- public void DebuggerAttributesValid(IEnumerable source)
+ public void DebuggerAttributesValid_AdditionalCases(IEnumerable source)
{
DebuggerAttributes.ValidateDebuggerDisplayReferences(source.ToImmutableArray());
}
diff --git a/src/libraries/System.Collections.Immutable/tests/ImmutableSetTest.cs b/src/libraries/System.Collections.Immutable/tests/ImmutableSetTest.cs
index a0d0df5ea071d6..511f2da0baffc4 100644
--- a/src/libraries/System.Collections.Immutable/tests/ImmutableSetTest.cs
+++ b/src/libraries/System.Collections.Immutable/tests/ImmutableSetTest.cs
@@ -40,7 +40,23 @@ public void AddRemoveLoadTest()
[Fact]
public void RemoveNonExistingTest()
{
- this.RemoveNonExistingTest(this.Empty());
+ IImmutableSet emptySet = this.Empty();
+ Assert.Same(emptySet, emptySet.Remove(5));
+
+ // Also fill up a set with many elements to build up the tree, then remove from various places in the tree.
+ const int Size = 200;
+ var set = emptySet;
+ for (int i = 0; i < Size; i += 2)
+ { // only even numbers!
+ set = set.Add(i);
+ }
+
+ // Verify that removing odd numbers doesn't change anything.
+ for (int i = 1; i < Size; i += 2)
+ {
+ var setAfterRemoval = set.Remove(i);
+ Assert.Same(set, setAfterRemoval);
+ }
}
[Fact]
@@ -381,26 +397,6 @@ private void RemoveTestHelper(IImmutableSet set, params T[] values)
Assert.Equal(initialCount - removedCount, set.Count);
}
- private void RemoveNonExistingTest(IImmutableSet emptySet)
- {
- Assert.Same(emptySet, emptySet.Remove(5));
-
- // Also fill up a set with many elements to build up the tree, then remove from various places in the tree.
- const int Size = 200;
- var set = emptySet;
- for (int i = 0; i < Size; i += 2)
- { // only even numbers!
- set = set.Add(i);
- }
-
- // Verify that removing odd numbers doesn't change anything.
- for (int i = 1; i < Size; i += 2)
- {
- var setAfterRemoval = set.Remove(i);
- Assert.Same(set, setAfterRemoval);
- }
- }
-
private void AddRemoveLoadTestHelper(IImmutableSet set, T[] data)
{
Assert.NotNull(set);
diff --git a/src/libraries/System.Collections.Specialized/tests/NameObjectCollectionBase/NameObjectCollectionBase.KeysTests.cs b/src/libraries/System.Collections.Specialized/tests/NameObjectCollectionBase/NameObjectCollectionBase.KeysTests.cs
index f4e022abef74c5..d68474ad01f3d5 100644
--- a/src/libraries/System.Collections.Specialized/tests/NameObjectCollectionBase/NameObjectCollectionBase.KeysTests.cs
+++ b/src/libraries/System.Collections.Specialized/tests/NameObjectCollectionBase/NameObjectCollectionBase.KeysTests.cs
@@ -106,7 +106,7 @@ public void Keys_Properties(int count)
public void Keys_CopyTo(int count, int index)
{
MyNameObjectCollection nameObjectCollection = Helpers.CreateNameObjectCollection(count);
- Keys_CopyTo(nameObjectCollection, index);
+ Keys_CopyTo_Helper(nameObjectCollection, index);
}
[Fact]
@@ -118,10 +118,10 @@ public void Keys_CopyTo_NullKeys()
nameObjectCollection.Add(null, null);
nameObjectCollection.Add(null, new Foo("3"));
- Keys_CopyTo(nameObjectCollection, 0);
+ Keys_CopyTo_Helper(nameObjectCollection, 0);
}
- private static void Keys_CopyTo(MyNameObjectCollection nameObjectCollection, int index)
+ private static void Keys_CopyTo_Helper(MyNameObjectCollection nameObjectCollection, int index)
{
ICollection keys = nameObjectCollection.Keys;
string[] keysArray = new string[index + keys.Count + index];
diff --git a/src/libraries/System.Collections/tests/Generic/Comparers/EqualityComparer.Tests.cs b/src/libraries/System.Collections/tests/Generic/Comparers/EqualityComparer.Tests.cs
index ce30429a39aa34..70d5715f2b4e65 100644
--- a/src/libraries/System.Collections/tests/Generic/Comparers/EqualityComparer.Tests.cs
+++ b/src/libraries/System.Collections/tests/Generic/Comparers/EqualityComparer.Tests.cs
@@ -37,7 +37,7 @@ public class HashData : TheoryData { }
[MemberData(nameof(Int64EnumData))]
[MemberData(nameof(NonEquatableValueTypeData))]
[MemberData(nameof(ObjectData))]
- public void Equals(T left, T right, bool expected)
+ public void EqualsTest(T left, T right, bool expected)
{
var comparer = EqualityComparer.Default;
IEqualityComparer nonGenericComparer = comparer;
@@ -305,7 +305,7 @@ public static EqualsData