"Don't directly throw Exception" System.ComponentModel.TypeConverter (#26050)

MarcoRossignoli · safern · commit 0101324f1ac8 · 2017-12-28T12:30:46.000-06:00
* Don't directly throw Exception

* Don't directly throw Exception
diff --git a/src/Common/src/System/Drawing/ColorConverterCommon.cs b/src/Common/src/System/Drawing/ColorConverterCommon.cs
@@ -128,7 +128,7 @@ private static int IntFromString(string text, CultureInfo culture)
             }
             catch (Exception e)
             {
-                throw new Exception(SR.Format(SR.ConvertInvalidPrimitive, text, typeof(int).Name), e);
+                throw new ArgumentException(SR.Format(SR.ConvertInvalidPrimitive, text, typeof(int).Name), e);
             }
         }
 
@@ -142,4 +142,4 @@ private static int IntFromString(string value, NumberFormatInfo formatInfo)
             return Int32.Parse(value, NumberStyles.Integer, formatInfo);
         }
     }
-}
+}
diff --git a/src/System.ComponentModel.Annotations/tests/RangeAttributeTests.cs b/src/System.ComponentModel.Annotations/tests/RangeAttributeTests.cs
@@ -36,7 +36,7 @@ protected override IEnumerable<TestCase> ValidValues()
             yield return new TestCase(stringIntRange, "2");
             yield return new TestCase(stringIntRange, 3);
             yield return new TestCase(stringIntRange, "3");
-            
+
             RangeAttribute stringDoubleRange = new RangeAttribute(typeof(double), (1.0).ToString("F1"), (3.0).ToString("F1"));
             yield return new TestCase(stringDoubleRange, null);
             yield return new TestCase(stringDoubleRange, string.Empty);
@@ -91,8 +91,8 @@ protected override IEnumerable<TestCase> InvalidValues()
         public static void Validate_CantConvertValueToTargetType_ThrowsException(Type type, string minimum, string maximum)
         {
             var attribute = new RangeAttribute(type, minimum, maximum);
-            Assert.Throws<Exception>(() => attribute.Validate("abc", new ValidationContext(new object())));
-            Assert.Throws<Exception>(() => attribute.IsValid("abc"));
+            AssertExtensions.Throws<ArgumentException, Exception>(() => attribute.Validate("abc", new ValidationContext(new object())));
+            AssertExtensions.Throws<ArgumentException, Exception>(() => attribute.IsValid("abc"));
         }
 
         [Fact]
@@ -168,7 +168,7 @@ public static void Validate_MinimumOrMaximumNull_ThrowsInvalidOperationException
         public static void Validate_MinimumOrMaximumCantBeConvertedToIntegralType_ThrowsException(Type type, string minimum, string maximum)
         {
             RangeAttribute attribute = new RangeAttribute(type, minimum, maximum);
-            Assert.Throws<Exception>(() => attribute.Validate("Any", new ValidationContext(new object())));
+            AssertExtensions.Throws<ArgumentException, Exception>(() => attribute.Validate("Any", new ValidationContext(new object())));
         }
 
         [Theory]
diff --git a/src/System.ComponentModel.TypeConverter/src/System/ComponentModel/BaseNumberConverter.cs b/src/System.ComponentModel.TypeConverter/src/System/ComponentModel/BaseNumberConverter.cs
@@ -34,15 +34,7 @@ internal abstract Type TargetType
         /// Convert the given value to a string using the given formatInfo
         /// </summary>
         internal abstract object FromString(string value, NumberFormatInfo formatInfo);
-
-        /// <summary>
-        /// Create an error based on the failed text and the exception thrown.
-        /// </summary>
-        internal virtual Exception FromStringError(string failedText, Exception innerException)
-        {
-            return new Exception(SR.Format(SR.ConvertInvalidPrimitive, failedText, TargetType.Name), innerException);
-        }
-
+      
         /// <summary>
         /// Convert the given value from a string using the given formatInfo
         /// </summary>
@@ -90,7 +82,7 @@ public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo c
                 }
                 catch (Exception e)
                 {
-                    throw FromStringError(text, e);
+                    throw new ArgumentException(SR.Format(SR.ConvertInvalidPrimitive, text, TargetType.Name), nameof(value), e);
                 }
             }
             return base.ConvertFrom(context, culture, value);
diff --git a/src/System.ComponentModel.TypeConverter/tests/ByteConvertersTests.cs b/src/System.ComponentModel.TypeConverter/tests/ByteConvertersTests.cs
@@ -53,7 +53,7 @@ public static void ConvertFrom_WithContext()
         [Fact]
         public static void ConvertFrom_WithContext_Negative()
         {
-            Assert.Throws<Exception>(
+            AssertExtensions.Throws<ArgumentException, Exception>(
                 () => ByteConverterTests.s_converter.ConvertFrom(TypeConverterTests.s_context, null, "8.0"));
         }
 
diff --git a/src/System.ComponentModel.TypeConverter/tests/DecimalConverterTests.cs b/src/System.ComponentModel.TypeConverter/tests/DecimalConverterTests.cs
@@ -25,8 +25,8 @@ public static void ConvertFrom_WithContext()
         [Fact]
         public static void ConvertFrom_WithContext_Negative()
         {
-            Assert.Throws<Exception>(
-                () => DecimalConverterTests.s_converter.ConvertFrom(TypeConverterTests.s_context, null, "0x8"));
+           AssertExtensions.Throws<ArgumentException, Exception>(
+               () => DecimalConverterTests.s_converter.ConvertFrom(TypeConverterTests.s_context, null, "0x8"));
         }
 
         [Fact]
diff --git a/src/System.ComponentModel.TypeConverter/tests/DoubleConverterTests.cs b/src/System.ComponentModel.TypeConverter/tests/DoubleConverterTests.cs
@@ -25,7 +25,7 @@ public static void ConvertFrom_WithContext()
         [Fact]
         public static void ConvertFrom_WithContext_Negative()
         {
-            Assert.Throws<Exception>(
+            AssertExtensions.Throws<ArgumentException, Exception>(
                 () => DoubleConverterTests.s_converter.ConvertFrom(TypeConverterTests.s_context, null, "0x8"));
         }
 
diff --git a/src/System.ComponentModel.TypeConverter/tests/Drawing/ColorConverterTests.cs b/src/System.ComponentModel.TypeConverter/tests/Drawing/ColorConverterTests.cs
@@ -76,7 +76,7 @@ public static IEnumerable<object[]> ColorData
                         {
                             for (int b = 0; b < 256; b += 67)
                             {
-                                yield return new object[] {a, r, g, b};
+                                yield return new object[] { a, r, g, b };
                             }
                         }
                     }
@@ -86,25 +86,25 @@ public static IEnumerable<object[]> ColorData
 
         public static IEnumerable<object[]> ColorNames => typeof(Color).GetProperties()
                 .Where(p => p.PropertyType == typeof(Color))
-                .Select(p => new object[] { p.Name} );
+                .Select(p => new object[] { p.Name });
 
         [Theory]
         [MemberData(nameof(ColorData))]
         public void ConvertFrom(int a, int r, int g, int b)
         {
             var conv = new ColorConverter();
-            Color color = (Color) conv.ConvertFrom(null, CultureInfo.InvariantCulture, $"#0x{a:x2}{r:x2}{g:x2}{b:x2}");
+            Color color = (Color)conv.ConvertFrom(null, CultureInfo.InvariantCulture, $"#0x{a:x2}{r:x2}{g:x2}{b:x2}");
             Assert.Equal(a, color.A);
             Assert.Equal(r, color.R);
             Assert.Equal(g, color.G);
             Assert.Equal(b, color.B);
 
             Assert.Equal(color,
-                (Color) conv.ConvertFrom(null, CultureInfo.InvariantCulture, $"#0X{a:x2}{r:x2}{g:x2}{b:x2}"));
+                (Color)conv.ConvertFrom(null, CultureInfo.InvariantCulture, $"#0X{a:x2}{r:x2}{g:x2}{b:x2}"));
             Assert.Equal(color,
-                (Color) conv.ConvertFrom(null, CultureInfo.InvariantCulture, $"0x{a:x2}{r:x2}{g:x2}{b:x2}"));
+                (Color)conv.ConvertFrom(null, CultureInfo.InvariantCulture, $"0x{a:x2}{r:x2}{g:x2}{b:x2}"));
             Assert.Equal(color,
-                (Color) conv.ConvertFrom(null, CultureInfo.InvariantCulture, $"0X{a:x2}{r:x2}{g:x2}{b:x2}"));
+                (Color)conv.ConvertFrom(null, CultureInfo.InvariantCulture, $"0X{a:x2}{r:x2}{g:x2}{b:x2}"));
         }
 
         [Theory]
@@ -146,17 +146,17 @@ public void ConvertFrom_Name(string name)
         {
             var conv = new ColorConverter();
             var color = Color.FromName(name);
-            Assert.Equal(color, (Color) conv.ConvertFrom(name));
-            Assert.Equal(color, (Color) conv.ConvertFrom(" " + name + " "));
+            Assert.Equal(color, (Color)conv.ConvertFrom(name));
+            Assert.Equal(color, (Color)conv.ConvertFrom(" " + name + " "));
         }
 
         [Fact]
         public void ConvertFrom_Empty()
         {
             var conv = new ColorConverter();
             var color = Color.Empty;
-            Assert.Equal(color, (Color) conv.ConvertFrom(string.Empty));
-            Assert.Equal(color, (Color) conv.ConvertFrom(" "));
+            Assert.Equal(color, (Color)conv.ConvertFrom(string.Empty));
+            Assert.Equal(color, (Color)conv.ConvertFrom(" "));
         }
 
         [Theory]
@@ -177,7 +177,7 @@ public void ConvertFrom_ArgumentException(string value)
         public void ConvertFrom_Exception(string value)
         {
             var conv = new ColorConverter();
-            Assert.Throws<Exception>(() =>
+            AssertExtensions.Throws<ArgumentException, Exception>(() =>
             {
                 conv.ConvertFrom(null, CultureInfo.InvariantCulture, value);
             });
@@ -208,7 +208,7 @@ public void ConvertFrom_NotSupportedException(object value)
         public void ConvertFrom_NullCulture()
         {
             var conv = new ColorConverter();
-            var color = (Color) conv.ConvertFrom(null, null, "#0x23190A44");
+            var color = (Color)conv.ConvertFrom(null, null, "#0x23190A44");
             Assert.Equal(35, color.A);
             Assert.Equal(25, color.R);
             Assert.Equal(10, color.G);
@@ -221,7 +221,7 @@ public void ConvertTo(int a, int r, int g, int b)
         {
             var conv = new ColorConverter();
             Assert.Equal($"{a}, {r}, {g}, {b}",
-                (string) conv.ConvertTo(null, CultureInfo.InvariantCulture, Color.FromArgb(a, r, g, b), typeof(string)));
+                (string)conv.ConvertTo(null, CultureInfo.InvariantCulture, Color.FromArgb(a, r, g, b), typeof(string)));
         }
 
         [Theory]
@@ -230,15 +230,15 @@ public void ConvertTo_Named(string name)
         {
             var conv = new ColorConverter();
             Assert.Equal(name,
-                (string) conv.ConvertTo(null, CultureInfo.InvariantCulture, Color.FromName(name), typeof(string)));
+                (string)conv.ConvertTo(null, CultureInfo.InvariantCulture, Color.FromName(name), typeof(string)));
         }
 
         [Fact]
         public void ConvertTo_Empty()
         {
             var conv = new ColorConverter();
             Assert.Equal(string.Empty,
-                (string) conv.ConvertTo(null, CultureInfo.InvariantCulture, Color.Empty, typeof(string)));
+                (string)conv.ConvertTo(null, CultureInfo.InvariantCulture, Color.Empty, typeof(string)));
         }
 
         [Theory]
@@ -306,7 +306,7 @@ public void GetProperties()
         public void ConvertFromInvariantString(int a, int r, int g, int b)
         {
             var conv = new ColorConverter();
-            var color = (Color) conv.ConvertFromInvariantString($"{a}, {r}, {g}, {b}");
+            var color = (Color)conv.ConvertFromInvariantString($"{a}, {r}, {g}, {b}");
             Assert.Equal(a, color.A);
             Assert.Equal(r, color.R);
             Assert.Equal(g, color.G);
@@ -319,7 +319,7 @@ public void ConvertFromInvariantString_Name(string name)
         {
             var conv = new ColorConverter();
             var color = Color.FromName(name);
-            Assert.Equal(color, (Color) conv.ConvertFromInvariantString(name));
+            Assert.Equal(color, (Color)conv.ConvertFromInvariantString(name));
         }
 
         [Fact]
@@ -336,7 +336,7 @@ public void ConvertFromInvariantString_Invalid()
         public void ConvertFromInvariantString_NotNumber()
         {
             var conv = new ColorConverter();
-            var ex = Assert.Throws<Exception>(() =>
+            var ex = AssertExtensions.Throws<ArgumentException, Exception>(() =>
             {
                 conv.ConvertFromInvariantString("hello");
             });
@@ -365,7 +365,7 @@ public void ConvertFromString_Name(string name)
         {
             var conv = new ColorConverter();
             var color = Color.FromName(name);
-            Assert.Equal(color, (Color) conv.ConvertFromString(name));
+            Assert.Equal(color, (Color)conv.ConvertFromString(name));
         }
 
         [Fact]
@@ -382,7 +382,7 @@ public void ConvertFromString_Invalid()
         public void ConvertFromString_NotNumber()
         {
             var conv = new ColorConverter();
-            var ex = Assert.Throws<Exception>(() =>
+            var ex = AssertExtensions.Throws<ArgumentException, Exception>(() =>
             {
                 conv.ConvertFromString("hello");
             });
diff --git a/src/System.ComponentModel.TypeConverter/tests/Drawing/StringTypeConverterTestBase.cs b/src/System.ComponentModel.TypeConverter/tests/Drawing/StringTypeConverterTestBase.cs
@@ -88,7 +88,7 @@ protected void ConvertFromThrowsArgumentExceptionForString(string value)
 
         protected void ConvertFromThrowsFormatInnerExceptionForString(string value)
         {
-            var ex = Assert.Throws<Exception>(() =>
+            var ex = AssertExtensions.Throws<ArgumentException, Exception>(() =>
             {
                 Converter.ConvertFrom(null, CultureInfo.InvariantCulture, value);
             });
@@ -145,7 +145,7 @@ protected void ConvertFromInvariantStringThrowsArgumentException(string str)
 
         protected void ConvertFromInvariantStringThrowsFormatInnerException(string str)
         {
-            var ex = Assert.Throws<Exception>(() =>
+            var ex = AssertExtensions.Throws<ArgumentException, Exception>(() =>
             {
                 Converter.ConvertFromInvariantString(str);
             });
@@ -163,7 +163,7 @@ protected void ConvertFromStringThrowsArgumentException(string str)
 
         protected void ConvertFromStringThrowsFormatInnerException(string str)
         {
-            var ex = Assert.Throws<Exception>(() =>
+            var ex = AssertExtensions.Throws<ArgumentException, Exception>(() =>
             {
                 Converter.ConvertFromString(str);
             });
diff --git a/src/System.ComponentModel.TypeConverter/tests/Int16ConverterTests.cs b/src/System.ComponentModel.TypeConverter/tests/Int16ConverterTests.cs
@@ -26,8 +26,8 @@ public static void ConvertFrom_WithContext()
         [Fact]
         public static void ConvertFrom_WithContext_Negative()
         {
-            Assert.Throws<Exception>(
-                () => Int16ConverterTests.s_converter.ConvertFrom(TypeConverterTests.s_context, null, "8.0"));
+           AssertExtensions.Throws<ArgumentException, Exception>(
+               () => Int16ConverterTests.s_converter.ConvertFrom(TypeConverterTests.s_context, null, "8.0"));
         }
 
         [Fact]
diff --git a/src/System.ComponentModel.TypeConverter/tests/Int32ConverterTests.cs b/src/System.ComponentModel.TypeConverter/tests/Int32ConverterTests.cs
@@ -26,7 +26,7 @@ public static void ConvertFrom_WithContext()
         [Fact]
         public static void ConvertFrom_WithContext_Negative()
         {
-            Assert.Throws<Exception>(
+            AssertExtensions.Throws<ArgumentException, Exception>(
                 () => Int32ConverterTests.s_converter.ConvertFrom(TypeConverterTests.s_context, null, "8.0"));
         }
 
diff --git a/src/System.ComponentModel.TypeConverter/tests/Int64ConverterTests.cs b/src/System.ComponentModel.TypeConverter/tests/Int64ConverterTests.cs
@@ -26,7 +26,7 @@ public static void ConvertFrom_WithContext()
         [Fact]
         public static void ConvertFrom_WithContext_Negative()
         {
-            Assert.Throws<Exception>(
+            AssertExtensions.Throws<ArgumentException, Exception>(
                 () => Int64ConverterTests.s_converter.ConvertFrom(TypeConverterTests.s_context, null, "8.0"));
         }
 
diff --git a/src/System.ComponentModel.TypeConverter/tests/PropertyDescriptorTests.cs b/src/System.ComponentModel.TypeConverter/tests/PropertyDescriptorTests.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System.Reflection;
 using Xunit;
 
 namespace System.ComponentModel.Tests
@@ -104,7 +105,7 @@ public void GetValueDoesNotHandleExceptions()
             var properties = TypeDescriptor.GetProperties(component.GetType());
             PropertyDescriptor propertyDescriptor = properties.Find(nameof(component.PropertyWhichThrows), false);
 
-            Assert.ThrowsAny<Exception>(() => propertyDescriptor.GetValue(component));
+            Assert.Throws<TargetInvocationException>(() => propertyDescriptor.GetValue(component));
         }
 
         [Fact]
diff --git a/src/System.ComponentModel.TypeConverter/tests/SByteConverterTests.cs b/src/System.ComponentModel.TypeConverter/tests/SByteConverterTests.cs
@@ -26,7 +26,7 @@ public static void ConvertFrom_WithContext()
         [Fact]
         public static void ConvertFrom_WithContext_Negative()
         {
-            Assert.Throws<Exception>(
+            AssertExtensions.Throws<ArgumentException, Exception>(
                 () => SByteConverterTests.s_converter.ConvertFrom(TypeConverterTests.s_context, null, "8.0"));
         }
 
diff --git a/src/System.ComponentModel.TypeConverter/tests/SingleConverterTests.cs b/src/System.ComponentModel.TypeConverter/tests/SingleConverterTests.cs
@@ -25,7 +25,7 @@ public static void ConvertFrom_WithContext()
         [Fact]
         public static void ConvertFrom_WithContext_Negative()
         {
-            Assert.Throws<Exception>(
+            AssertExtensions.Throws<ArgumentException, Exception>(
                 () => SingleConverterTests.s_converter.ConvertFrom(TypeConverterTests.s_context, null, "0x8"));
         }
 
diff --git a/src/System.ComponentModel.TypeConverter/tests/UInt16ConverterTests.cs b/src/System.ComponentModel.TypeConverter/tests/UInt16ConverterTests.cs
@@ -26,7 +26,7 @@ public static void ConvertFrom_WithContext()
         [Fact]
         public static void ConvertFrom_WithContext_Negative()
         {
-            Assert.Throws<Exception>(
+            AssertExtensions.Throws<ArgumentException, Exception>(
                 () => UInt16ConverterTests.s_converter.ConvertFrom(TypeConverterTests.s_context, null, "-8"));
         }
 
diff --git a/src/System.ComponentModel.TypeConverter/tests/UInt32ConverterTests.cs b/src/System.ComponentModel.TypeConverter/tests/UInt32ConverterTests.cs
@@ -26,7 +26,7 @@ public static void ConvertFrom_WithContext()
         [Fact]
         public static void ConvertFrom_WithContext_Negative()
         {
-            Assert.Throws<Exception>(
+            AssertExtensions.Throws<ArgumentException, Exception>(
                 () => UInt32ConverterTests.s_converter.ConvertFrom(TypeConverterTests.s_context, null, "-8"));
         }
 
diff --git a/src/System.ComponentModel.TypeConverter/tests/UInt64ConverterTests.cs b/src/System.ComponentModel.TypeConverter/tests/UInt64ConverterTests.cs
@@ -26,7 +26,7 @@ public static void ConvertFrom_WithContext()
         [Fact]
         public static void ConvertFrom_WithContext_Negative()
         {
-            Assert.Throws<Exception>(
+            AssertExtensions.Throws<ArgumentException, Exception>(
                 () => UInt64ConverterTests.s_converter.ConvertFrom(TypeConverterTests.s_context, null, "-8"));
         }
 

Original file line number	Diff line number	Diff line change
`@@ -128,7 +128,7 @@ private static int IntFromString(string text, CultureInfo culture)`
`128`	`128`	`}`
`129`	`129`	`catch (Exception e)`
`130`	`130`	`{`
`131`		`- throw new Exception(SR.Format(SR.ConvertInvalidPrimitive, text, typeof(int).Name), e);`
	`131`	`+ throw new ArgumentException(SR.Format(SR.ConvertInvalidPrimitive, text, typeof(int).Name), e);`
`132`	`132`	`}`
`133`	`133`	`}`
`134`	`134`
`@@ -142,4 +142,4 @@ private static int IntFromString(string value, NumberFormatInfo formatInfo)`
`142`	`142`	`return Int32.Parse(value, NumberStyles.Integer, formatInfo);`
`143`	`143`	`}`
`144`	`144`	`}`
`145`		`-}`
	`145`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ public static void ConvertFrom_WithContext()`
`53`	`53`	`[Fact]`
`54`	`54`	`public static void ConvertFrom_WithContext_Negative()`
`55`	`55`	`{`
`56`		`- Assert.Throws<Exception>(`
	`56`	`+ AssertExtensions.Throws<ArgumentException, Exception>(`
`57`	`57`	`() => ByteConverterTests.s_converter.ConvertFrom(TypeConverterTests.s_context, null, "8.0"));`
`58`	`58`	`}`
`59`	`59`
Original file line number	Diff line number	Diff line change
`@@ -25,8 +25,8 @@ public static void ConvertFrom_WithContext()`
`25`	`25`	`[Fact]`
`26`	`26`	`public static void ConvertFrom_WithContext_Negative()`
`27`	`27`	`{`
`28`		`- Assert.Throws<Exception>(`
`29`		`- () => DecimalConverterTests.s_converter.ConvertFrom(TypeConverterTests.s_context, null, "0x8"));`
	`28`	`+ AssertExtensions.Throws<ArgumentException, Exception>(`
	`29`	`+ () => DecimalConverterTests.s_converter.ConvertFrom(TypeConverterTests.s_context, null, "0x8"));`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`[Fact]`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ public static void ConvertFrom_WithContext()`
`25`	`25`	`[Fact]`
`26`	`26`	`public static void ConvertFrom_WithContext_Negative()`
`27`	`27`	`{`
`28`		`- Assert.Throws<Exception>(`
	`28`	`+ AssertExtensions.Throws<ArgumentException, Exception>(`
`29`	`29`	`() => DoubleConverterTests.s_converter.ConvertFrom(TypeConverterTests.s_context, null, "0x8"));`
`30`	`30`	`}`
`31`	`31`
Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ public static IEnumerable<object[]> ColorData`
`76`	`76`	`{`
`77`	`77`	`for (int b = 0; b < 256; b += 67)`
`78`	`78`	`{`
`79`		`- yield return new object[] {a, r, g, b};`
	`79`	`+ yield return new object[] { a, r, g, b };`
`80`	`80`	`}`
`81`	`81`	`}`
`82`	`82`	`}`
`@@ -86,25 +86,25 @@ public static IEnumerable<object[]> ColorData`
`86`	`86`
`87`	`87`	`public static IEnumerable<object[]> ColorNames => typeof(Color).GetProperties()`
`88`	`88`	`.Where(p => p.PropertyType == typeof(Color))`
`89`		`- .Select(p => new object[] { p.Name} );`
	`89`	`+ .Select(p => new object[] { p.Name });`
`90`	`90`
`91`	`91`	`[Theory]`
`92`	`92`	`[MemberData(nameof(ColorData))]`
`93`	`93`	`public void ConvertFrom(int a, int r, int g, int b)`
`94`	`94`	`{`
`95`	`95`	`var conv = new ColorConverter();`
`96`		`- Color color = (Color) conv.ConvertFrom(null, CultureInfo.InvariantCulture, $"#0x{a:x2}{r:x2}{g:x2}{b:x2}");`
	`96`	`+ Color color = (Color)conv.ConvertFrom(null, CultureInfo.InvariantCulture, $"#0x{a:x2}{r:x2}{g:x2}{b:x2}");`
`97`	`97`	`Assert.Equal(a, color.A);`
`98`	`98`	`Assert.Equal(r, color.R);`
`99`	`99`	`Assert.Equal(g, color.G);`
`100`	`100`	`Assert.Equal(b, color.B);`
`101`	`101`
`102`	`102`	`Assert.Equal(color,`
`103`		`- (Color) conv.ConvertFrom(null, CultureInfo.InvariantCulture, $"#0X{a:x2}{r:x2}{g:x2}{b:x2}"));`
	`103`	`+ (Color)conv.ConvertFrom(null, CultureInfo.InvariantCulture, $"#0X{a:x2}{r:x2}{g:x2}{b:x2}"));`
`104`	`104`	`Assert.Equal(color,`
`105`		`- (Color) conv.ConvertFrom(null, CultureInfo.InvariantCulture, $"0x{a:x2}{r:x2}{g:x2}{b:x2}"));`
	`105`	`+ (Color)conv.ConvertFrom(null, CultureInfo.InvariantCulture, $"0x{a:x2}{r:x2}{g:x2}{b:x2}"));`
`106`	`106`	`Assert.Equal(color,`
`107`		`- (Color) conv.ConvertFrom(null, CultureInfo.InvariantCulture, $"0X{a:x2}{r:x2}{g:x2}{b:x2}"));`
	`107`	`+ (Color)conv.ConvertFrom(null, CultureInfo.InvariantCulture, $"0X{a:x2}{r:x2}{g:x2}{b:x2}"));`
`108`	`108`	`}`
`109`	`109`
`110`	`110`	`[Theory]`
`@@ -146,17 +146,17 @@ public void ConvertFrom_Name(string name)`
`146`	`146`	`{`
`147`	`147`	`var conv = new ColorConverter();`
`148`	`148`	`var color = Color.FromName(name);`
`149`		`- Assert.Equal(color, (Color) conv.ConvertFrom(name));`
`150`		`- Assert.Equal(color, (Color) conv.ConvertFrom(" " + name + " "));`
	`149`	`+ Assert.Equal(color, (Color)conv.ConvertFrom(name));`
	`150`	`+ Assert.Equal(color, (Color)conv.ConvertFrom(" " + name + " "));`
`151`	`151`	`}`
`152`	`152`
`153`	`153`	`[Fact]`
`154`	`154`	`public void ConvertFrom_Empty()`
`155`	`155`	`{`
`156`	`156`	`var conv = new ColorConverter();`
`157`	`157`	`var color = Color.Empty;`
`158`		`- Assert.Equal(color, (Color) conv.ConvertFrom(string.Empty));`
`159`		`- Assert.Equal(color, (Color) conv.ConvertFrom(" "));`
	`158`	`+ Assert.Equal(color, (Color)conv.ConvertFrom(string.Empty));`
	`159`	`+ Assert.Equal(color, (Color)conv.ConvertFrom(" "));`
`160`	`160`	`}`
`161`	`161`
`162`	`162`	`[Theory]`
`@@ -177,7 +177,7 @@ public void ConvertFrom_ArgumentException(string value)`
`177`	`177`	`public void ConvertFrom_Exception(string value)`
`178`	`178`	`{`
`179`	`179`	`var conv = new ColorConverter();`
`180`		`- Assert.Throws<Exception>(() =>`
	`180`	`+ AssertExtensions.Throws<ArgumentException, Exception>(() =>`
`181`	`181`	`{`
`182`	`182`	`conv.ConvertFrom(null, CultureInfo.InvariantCulture, value);`
`183`	`183`	`});`
`@@ -208,7 +208,7 @@ public void ConvertFrom_NotSupportedException(object value)`
`208`	`208`	`public void ConvertFrom_NullCulture()`
`209`	`209`	`{`
`210`	`210`	`var conv = new ColorConverter();`
`211`		`- var color = (Color) conv.ConvertFrom(null, null, "#0x23190A44");`
	`211`	`+ var color = (Color)conv.ConvertFrom(null, null, "#0x23190A44");`
`212`	`212`	`Assert.Equal(35, color.A);`
`213`	`213`	`Assert.Equal(25, color.R);`
`214`	`214`	`Assert.Equal(10, color.G);`
`@@ -221,7 +221,7 @@ public void ConvertTo(int a, int r, int g, int b)`
`221`	`221`	`{`
`222`	`222`	`var conv = new ColorConverter();`
`223`	`223`	`Assert.Equal($"{a}, {r}, {g}, {b}",`
`224`		`- (string) conv.ConvertTo(null, CultureInfo.InvariantCulture, Color.FromArgb(a, r, g, b), typeof(string)));`
	`224`	`+ (string)conv.ConvertTo(null, CultureInfo.InvariantCulture, Color.FromArgb(a, r, g, b), typeof(string)));`
`225`	`225`	`}`
`226`	`226`
`227`	`227`	`[Theory]`
`@@ -230,15 +230,15 @@ public void ConvertTo_Named(string name)`
`230`	`230`	`{`
`231`	`231`	`var conv = new ColorConverter();`
`232`	`232`	`Assert.Equal(name,`
`233`		`- (string) conv.ConvertTo(null, CultureInfo.InvariantCulture, Color.FromName(name), typeof(string)));`
	`233`	`+ (string)conv.ConvertTo(null, CultureInfo.InvariantCulture, Color.FromName(name), typeof(string)));`
`234`	`234`	`}`
`235`	`235`
`236`	`236`	`[Fact]`
`237`	`237`	`public void ConvertTo_Empty()`
`238`	`238`	`{`
`239`	`239`	`var conv = new ColorConverter();`
`240`	`240`	`Assert.Equal(string.Empty,`
`241`		`- (string) conv.ConvertTo(null, CultureInfo.InvariantCulture, Color.Empty, typeof(string)));`
	`241`	`+ (string)conv.ConvertTo(null, CultureInfo.InvariantCulture, Color.Empty, typeof(string)));`
`242`	`242`	`}`
`243`	`243`
`244`	`244`	`[Theory]`
`@@ -306,7 +306,7 @@ public void GetProperties()`
`306`	`306`	`public void ConvertFromInvariantString(int a, int r, int g, int b)`
`307`	`307`	`{`
`308`	`308`	`var conv = new ColorConverter();`
`309`		`- var color = (Color) conv.ConvertFromInvariantString($"{a}, {r}, {g}, {b}");`
	`309`	`+ var color = (Color)conv.ConvertFromInvariantString($"{a}, {r}, {g}, {b}");`
`310`	`310`	`Assert.Equal(a, color.A);`
`311`	`311`	`Assert.Equal(r, color.R);`
`312`	`312`	`Assert.Equal(g, color.G);`
`@@ -319,7 +319,7 @@ public void ConvertFromInvariantString_Name(string name)`
`319`	`319`	`{`
`320`	`320`	`var conv = new ColorConverter();`
`321`	`321`	`var color = Color.FromName(name);`
`322`		`- Assert.Equal(color, (Color) conv.ConvertFromInvariantString(name));`
	`322`	`+ Assert.Equal(color, (Color)conv.ConvertFromInvariantString(name));`
`323`	`323`	`}`
`324`	`324`
`325`	`325`	`[Fact]`
`@@ -336,7 +336,7 @@ public void ConvertFromInvariantString_Invalid()`
`336`	`336`	`public void ConvertFromInvariantString_NotNumber()`
`337`	`337`	`{`
`338`	`338`	`var conv = new ColorConverter();`
`339`		`- var ex = Assert.Throws<Exception>(() =>`
	`339`	`+ var ex = AssertExtensions.Throws<ArgumentException, Exception>(() =>`
`340`	`340`	`{`
`341`	`341`	`conv.ConvertFromInvariantString("hello");`
`342`	`342`	`});`
`@@ -365,7 +365,7 @@ public void ConvertFromString_Name(string name)`
`365`	`365`	`{`
`366`	`366`	`var conv = new ColorConverter();`
`367`	`367`	`var color = Color.FromName(name);`
`368`		`- Assert.Equal(color, (Color) conv.ConvertFromString(name));`
	`368`	`+ Assert.Equal(color, (Color)conv.ConvertFromString(name));`
`369`	`369`	`}`
`370`	`370`
`371`	`371`	`[Fact]`
`@@ -382,7 +382,7 @@ public void ConvertFromString_Invalid()`
`382`	`382`	`public void ConvertFromString_NotNumber()`
`383`	`383`	`{`
`384`	`384`	`var conv = new ColorConverter();`
`385`		`- var ex = Assert.Throws<Exception>(() =>`
	`385`	`+ var ex = AssertExtensions.Throws<ArgumentException, Exception>(() =>`
`386`	`386`	`{`
`387`	`387`	`conv.ConvertFromString("hello");`
`388`	`388`	`});`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ protected void ConvertFromThrowsArgumentExceptionForString(string value)`
`88`	`88`
`89`	`89`	`protected void ConvertFromThrowsFormatInnerExceptionForString(string value)`
`90`	`90`	`{`
`91`		`- var ex = Assert.Throws<Exception>(() =>`
	`91`	`+ var ex = AssertExtensions.Throws<ArgumentException, Exception>(() =>`
`92`	`92`	`{`
`93`	`93`	`Converter.ConvertFrom(null, CultureInfo.InvariantCulture, value);`
`94`	`94`	`});`
`@@ -145,7 +145,7 @@ protected void ConvertFromInvariantStringThrowsArgumentException(string str)`
`145`	`145`
`146`	`146`	`protected void ConvertFromInvariantStringThrowsFormatInnerException(string str)`
`147`	`147`	`{`
`148`		`- var ex = Assert.Throws<Exception>(() =>`
	`148`	`+ var ex = AssertExtensions.Throws<ArgumentException, Exception>(() =>`
`149`	`149`	`{`
`150`	`150`	`Converter.ConvertFromInvariantString(str);`
`151`	`151`	`});`
`@@ -163,7 +163,7 @@ protected void ConvertFromStringThrowsArgumentException(string str)`
`163`	`163`
`164`	`164`	`protected void ConvertFromStringThrowsFormatInnerException(string str)`
`165`	`165`	`{`
`166`		`- var ex = Assert.Throws<Exception>(() =>`
	`166`	`+ var ex = AssertExtensions.Throws<ArgumentException, Exception>(() =>`
`167`	`167`	`{`
`168`	`168`	`Converter.ConvertFromString(str);`
`169`	`169`	`});`
Original file line number	Diff line number	Diff line change
`@@ -26,8 +26,8 @@ public static void ConvertFrom_WithContext()`
`26`	`26`	`[Fact]`
`27`	`27`	`public static void ConvertFrom_WithContext_Negative()`
`28`	`28`	`{`
`29`		`- Assert.Throws<Exception>(`
`30`		`- () => Int16ConverterTests.s_converter.ConvertFrom(TypeConverterTests.s_context, null, "8.0"));`
	`29`	`+ AssertExtensions.Throws<ArgumentException, Exception>(`
	`30`	`+ () => Int16ConverterTests.s_converter.ConvertFrom(TypeConverterTests.s_context, null, "8.0"));`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`[Fact]`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ public static void ConvertFrom_WithContext()`
`26`	`26`	`[Fact]`
`27`	`27`	`public static void ConvertFrom_WithContext_Negative()`
`28`	`28`	`{`
`29`		`- Assert.Throws<Exception>(`
	`29`	`+ AssertExtensions.Throws<ArgumentException, Exception>(`
`30`	`30`	`() => Int32ConverterTests.s_converter.ConvertFrom(TypeConverterTests.s_context, null, "8.0"));`
`31`	`31`	`}`
`32`	`32`