2010-01-25 Atsushi Enomoto <[email protected]>

Parse float and TimeSpan max/min values correctly.
Patch by Tiaan Geldenhuys.

svn path=/trunk/mcs/; revision=150102

mcs/class/System.XML/System.Xml/ChangeLog

@@ -1,3 +1,8 @@
+2010-01-25  Atsushi Enomoto  <[email protected]>
+
+	* XmlConvert.cs : convert TimeSpan.MinValue to correct string.
+	  Patch by Tiaan Geldenhuys.
+
 2010-01-22  Atsushi Enomoto  <[email protected]>
 
 	* XmlDocument.cs : fix type check for optimal node creation.

mcs/class/System.XML/System.Xml/XmlConvert.cs

@@ -551,6 +551,8 @@ namespace System.Xml {
 
 			StringBuilder builder = new StringBuilder ();
 			if (value.Ticks < 0) {
+				if (value == TimeSpan.MinValue)
+					return "-P10675199DT2H48M5.4775808S";  // There's one fewer tick on the positive side, so we cannot Negate this value; just hard-code it
 				builder.Append ('-');
 				value = value.Negate ();
 			}

mcs/class/System.XML/Test/System.Xml/ChangeLog

@@ -1,3 +1,8 @@
+2010-01-25  Atsushi Enomoto  <[email protected]>
+
+	* XmlConvertTest.cs : test convert TimeSpan.MinValue to string.
+	  Patch by Tiaan Geldenhuys.
+
 2010-01-15  Atsushi Enomoto  <[email protected]>
 
 	* XmlConvertTests.cs : add test for ToString(TimeSpan) with small

mcs/class/System.XML/Test/System.Xml/XmlConvertTests.cs

@@ -362,6 +362,9 @@ namespace MonoTests.System.Xml
 				XmlConvert.ToString (new DateTime (2003, 5, 5));
 			Assert.AreEqual (33, dateString.Length);
 			Assert.AreEqual (dateString.Substring (0, 27), "2003-05-05T00:00:00.0000000");
+
+			// Must not throw an exception...
+			Assert.IsNotNull ("-P10675199DT2H48M5.4775808S", XmlConvert.ToString (TimeSpan.MinValue));
 		}
 
 		[Test]

mcs/class/System.Xml.Linq/Test/System.Xml.Linq/ChangeLog

@@ -1,3 +1,8 @@
+2010-01-25  Atsushi Enomoto  <[email protected]>
+
+	* XElementTest.cs, XAttributeTest.cs : add corner case value conversion
+	  for numeric and TimeSpan values. Patch by Tiaan Geldenhuys.
+
 2010-01-15  Atsushi Enomoto  <[email protected]>
 
 	* XElementTest.cs, XAttributeTest.cs : add another set of extensive

mcs/class/System.Xml.Linq/Test/System.Xml.Linq/XAttributeTest.cs

@@ -692,6 +692,74 @@ namespace MonoTests.System.Xml.Linq
 			AssertThrows<OverflowException> (() => { ulong? z = (ulong?) new XAttribute ("z", -@decimal); }, "z:ulong?");
 		}
 
+		[Test]
+		public void CastExtremes ()
+		{
+			// Test extremes/constants where round-trips should work in specific ways
+			Assert.AreEqual (decimal.MaxValue, (decimal) new XAttribute ("k", decimal.MaxValue), "MaxValue:decimal");
+			Assert.AreEqual (decimal.MinValue, (decimal) new XAttribute ("k", decimal.MinValue), "MinValue:decimal");
+			Assert.AreEqual (decimal.MinusOne, (decimal) new XAttribute ("k", decimal.MinusOne), "MinusOne:decimal");
+			Assert.AreEqual (decimal.One, (decimal) new XAttribute ("k", decimal.One), "One:decimal");
+			Assert.AreEqual (decimal.Zero, (decimal) new XAttribute ("k", decimal.Zero), "Zero:decimal");
+			Assert.AreEqual (double.MaxValue, (double) new XAttribute ("k", double.MaxValue), "MaxValue:double");
+			Assert.AreEqual (double.MinValue, (double) new XAttribute ("k", double.MinValue), "MinValue:double");
+			Assert.AreEqual (double.Epsilon, (double) new XAttribute ("k", double.Epsilon), "Epsilon:double");
+			Assert.AreEqual (double.NaN, (double) new XAttribute ("k", double.NaN), "NaN:double");
+			Assert.AreEqual (double.NegativeInfinity, (double) new XAttribute ("k", double.NegativeInfinity), "-Inf:double");
+			Assert.AreEqual (double.PositiveInfinity, (double) new XAttribute ("k", double.PositiveInfinity), "+Inf:double");
+			Assert.AreEqual (float.MaxValue, (float) new XAttribute ("k", float.MaxValue), "MaxValue:float");
+			Assert.AreEqual (float.MinValue, (float) new XAttribute ("k", float.MinValue), "MinValue:float");
+			Assert.AreEqual (float.Epsilon, (float) new XAttribute ("k", float.Epsilon), "Epsilon:float");
+			Assert.AreEqual (float.NaN, (float) new XAttribute ("k", float.NaN), "NaN:float");
+			Assert.AreEqual (float.NegativeInfinity, (float) new XAttribute ("k", float.NegativeInfinity), "-Inf:float");
+			Assert.AreEqual (float.PositiveInfinity, (float) new XAttribute ("k", float.PositiveInfinity), "+Inf:float");
+			Assert.AreEqual (int.MaxValue, (int) new XAttribute ("k", int.MaxValue), "MaxValue:int");
+			Assert.AreEqual (int.MinValue, (int) new XAttribute ("k", int.MinValue), "MinValue:int");
+			Assert.AreEqual (long.MaxValue, (long) new XAttribute ("k", long.MaxValue), "MaxValue:long");
+			Assert.AreEqual (long.MinValue, (long) new XAttribute ("k", long.MinValue), "MinValue:long");
+			Assert.AreEqual (uint.MaxValue, (uint) new XAttribute ("k", uint.MaxValue), "MaxValue:uint");
+			Assert.AreEqual (uint.MinValue, (uint) new XAttribute ("k", uint.MinValue), "MinValue:uint");
+			Assert.AreEqual (ulong.MaxValue, (ulong) new XAttribute ("k", ulong.MaxValue), "MaxValue:ulong");
+			Assert.AreEqual (ulong.MinValue, (ulong) new XAttribute ("k", ulong.MinValue), "MinValue:ulong");
+			Assert.AreEqual (decimal.MaxValue, (decimal?) new XAttribute ("k", decimal.MaxValue), "MaxValue:decimal?");
+			Assert.AreEqual (decimal.MinValue, (decimal?) new XAttribute ("k", decimal.MinValue), "MinValue:decimal?");
+			Assert.AreEqual (decimal.MinusOne, (decimal?) new XAttribute ("k", decimal.MinusOne), "MinusOne:decimal?");
+			Assert.AreEqual (decimal.One, (decimal?) new XAttribute ("k", decimal.One), "One:decimal?");
+			Assert.AreEqual (decimal.Zero, (decimal?) new XAttribute ("k", decimal.Zero), "Zero:decimal?");
+			Assert.AreEqual (double.MaxValue, (double?) new XAttribute ("k", double.MaxValue), "MaxValue:double?");
+			Assert.AreEqual (double.MinValue, (double?) new XAttribute ("k", double.MinValue), "MinValue:double?");
+			Assert.AreEqual (double.Epsilon, (double?) new XAttribute ("k", double.Epsilon), "Epsilon:double?");
+			Assert.AreEqual (double.NaN, (double?) new XAttribute ("k", double.NaN), "NaN:double?");
+			Assert.AreEqual (double.NegativeInfinity, (double?) new XAttribute ("k", double.NegativeInfinity), "-Inf:double?");
+			Assert.AreEqual (double.PositiveInfinity, (double?) new XAttribute ("k", double.PositiveInfinity), "+Inf:double?");
+			Assert.AreEqual (float.MaxValue, (float?) new XAttribute ("k", float.MaxValue), "MaxValue:float?");
+			Assert.AreEqual (float.MinValue, (float?) new XAttribute ("k", float.MinValue), "MinValue:float?");
+			Assert.AreEqual (float.Epsilon, (float?) new XAttribute ("k", float.Epsilon), "Epsilon:float?");
+			Assert.AreEqual (float.NaN, (float?) new XAttribute ("k", float.NaN), "NaN:float?");
+			Assert.AreEqual (float.NegativeInfinity, (float?) new XAttribute ("k", float.NegativeInfinity), "-Inf:float?");
+			Assert.AreEqual (float.PositiveInfinity, (float?) new XAttribute ("k", float.PositiveInfinity), "+Inf:float?");
+			Assert.AreEqual (int.MaxValue, (int?) new XAttribute ("k", int.MaxValue), "MaxValue:int?");
+			Assert.AreEqual (int.MinValue, (int?) new XAttribute ("k", int.MinValue), "MinValue:int?");
+			Assert.AreEqual (long.MaxValue, (long?) new XAttribute ("k", long.MaxValue), "MaxValue:long?");
+			Assert.AreEqual (long.MinValue, (long?) new XAttribute ("k", long.MinValue), "MinValue:long?");
+			Assert.AreEqual (uint.MaxValue, (uint?) new XAttribute ("k", uint.MaxValue), "MaxValue:uint?");
+			Assert.AreEqual (uint.MinValue, (uint?) new XAttribute ("k", uint.MinValue), "MinValue:uint?");
+			Assert.AreEqual (ulong.MaxValue, (ulong?) new XAttribute ("k", ulong.MaxValue), "MaxValue:ulong?");
+			Assert.AreEqual (ulong.MinValue, (ulong?) new XAttribute ("k", ulong.MinValue), "MinValue:ulong?");
+			Assert.AreEqual (DateTime.MaxValue, (DateTime) new XAttribute ("k", DateTime.MaxValue), "MaxValue:DateTime");
+			Assert.AreEqual (DateTime.MinValue, (DateTime) new XAttribute ("k", DateTime.MinValue), "MinValue:DateTime");
+			Assert.AreEqual (DateTime.MaxValue, (DateTime?) new XAttribute ("k", DateTime.MaxValue), "MaxValue:DateTime?");
+			Assert.AreEqual (DateTime.MinValue, (DateTime?) new XAttribute ("k", DateTime.MinValue), "MinValue:DateTime?");
+			Assert.AreEqual (DateTimeOffset.MaxValue, (DateTimeOffset) new XAttribute ("k", DateTimeOffset.MaxValue), "MaxValue:DateTimeOffset");
+			Assert.AreEqual (DateTimeOffset.MinValue, (DateTimeOffset) new XAttribute ("k", DateTimeOffset.MinValue), "MinValue:DateTimeOffset");
+			Assert.AreEqual (DateTimeOffset.MaxValue, (DateTimeOffset?) new XAttribute ("k", DateTimeOffset.MaxValue), "MaxValue:DateTimeOffset?");
+			Assert.AreEqual (DateTimeOffset.MinValue, (DateTimeOffset?) new XAttribute ("k", DateTimeOffset.MinValue), "MinValue:DateTimeOffset?");
+			Assert.AreEqual (TimeSpan.MaxValue, (TimeSpan) new XAttribute ("k", TimeSpan.MaxValue), "MaxValue:TimeSpan");
+			Assert.AreEqual (TimeSpan.MinValue, (TimeSpan) new XAttribute ("k", TimeSpan.MinValue), "MinValue:TimeSpan");
+			Assert.AreEqual (TimeSpan.MaxValue, (TimeSpan?) new XAttribute ("k", TimeSpan.MaxValue), "MaxValue:TimeSpan?");
+			Assert.AreEqual (TimeSpan.MinValue, (TimeSpan?) new XAttribute ("k", TimeSpan.MinValue), "MinValue:TimeSpan?");
+		}
+
 		[Test]
 		public void CastBooleans ()
 		{
@@ -719,6 +787,8 @@ namespace MonoTests.System.Xml.Linq
 			Assert.IsNotNull ((bool?) new XAttribute ("x", false), "#14a");
 			Assert.IsFalse (((bool?) new XAttribute ("x", false)).Value, "#14b");
 			Assert.IsFalse ((bool) new XAttribute ("x", false), "#14c");
+			Assert.IsTrue ((bool) new XAttribute ("x", bool.TrueString), "#15a");
+			Assert.IsFalse ((bool) new XAttribute ("x", bool.FalseString), "#15b");
 		}
 
 		[Test]

mcs/class/System.Xml.Linq/Test/System.Xml.Linq/XElementTest.cs

@@ -1107,6 +1107,74 @@ namespace MonoTests.System.Xml.Linq
 			AssertThrows<OverflowException> (() => { ulong? z = (ulong?) new XElement ("z", -@decimal); }, "z:ulong?");
 		}
 
+		[Test]
+		public void CastExtremes ()
+		{
+			// Test extremes/constants where round-trips should work in specific ways
+			Assert.AreEqual (decimal.MaxValue, (decimal) new XElement ("k", decimal.MaxValue), "MaxValue:decimal");
+			Assert.AreEqual (decimal.MinValue, (decimal) new XElement ("k", decimal.MinValue), "MinValue:decimal");
+			Assert.AreEqual (decimal.MinusOne, (decimal) new XElement ("k", decimal.MinusOne), "MinusOne:decimal");
+			Assert.AreEqual (decimal.One, (decimal) new XElement ("k", decimal.One), "One:decimal");
+			Assert.AreEqual (decimal.Zero, (decimal) new XElement ("k", decimal.Zero), "Zero:decimal");
+			Assert.AreEqual (double.MaxValue, (double) new XElement ("k", double.MaxValue), "MaxValue:double");
+			Assert.AreEqual (double.MinValue, (double) new XElement ("k", double.MinValue), "MinValue:double");
+			Assert.AreEqual (double.Epsilon, (double) new XElement ("k", double.Epsilon), "Epsilon:double");
+			Assert.AreEqual (double.NaN, (double) new XElement ("k", double.NaN), "NaN:double");
+			Assert.AreEqual (double.NegativeInfinity, (double) new XElement ("k", double.NegativeInfinity), "-Inf:double");
+			Assert.AreEqual (double.PositiveInfinity, (double) new XElement ("k", double.PositiveInfinity), "+Inf:double");
+			Assert.AreEqual (float.MaxValue, (float) new XElement ("k", float.MaxValue), "MaxValue:float");
+			Assert.AreEqual (float.MinValue, (float) new XElement ("k", float.MinValue), "MinValue:float");
+			Assert.AreEqual (float.Epsilon, (float) new XElement ("k", float.Epsilon), "Epsilon:float");
+			Assert.AreEqual (float.NaN, (float) new XElement ("k", float.NaN), "NaN:float");
+			Assert.AreEqual (float.NegativeInfinity, (float) new XElement ("k", float.NegativeInfinity), "-Inf:float");
+			Assert.AreEqual (float.PositiveInfinity, (float) new XElement ("k", float.PositiveInfinity), "+Inf:float");
+			Assert.AreEqual (int.MaxValue, (int) new XElement ("k", int.MaxValue), "MaxValue:int");
+			Assert.AreEqual (int.MinValue, (int) new XElement ("k", int.MinValue), "MinValue:int");
+			Assert.AreEqual (long.MaxValue, (long) new XElement ("k", long.MaxValue), "MaxValue:long");
+			Assert.AreEqual (long.MinValue, (long) new XElement ("k", long.MinValue), "MinValue:long");
+			Assert.AreEqual (uint.MaxValue, (uint) new XElement ("k", uint.MaxValue), "MaxValue:uint");
+			Assert.AreEqual (uint.MinValue, (uint) new XElement ("k", uint.MinValue), "MinValue:uint");
+			Assert.AreEqual (ulong.MaxValue, (ulong) new XElement ("k", ulong.MaxValue), "MaxValue:ulong");
+			Assert.AreEqual (ulong.MinValue, (ulong) new XElement ("k", ulong.MinValue), "MinValue:ulong");
+			Assert.AreEqual (decimal.MaxValue, (decimal?) new XElement ("k", decimal.MaxValue), "MaxValue:decimal?");
+			Assert.AreEqual (decimal.MinValue, (decimal?) new XElement ("k", decimal.MinValue), "MinValue:decimal?");
+			Assert.AreEqual (decimal.MinusOne, (decimal?) new XElement ("k", decimal.MinusOne), "MinusOne:decimal?");
+			Assert.AreEqual (decimal.One, (decimal?) new XElement ("k", decimal.One), "One:decimal?");
+			Assert.AreEqual (decimal.Zero, (decimal?) new XElement ("k", decimal.Zero), "Zero:decimal?");
+			Assert.AreEqual (double.MaxValue, (double?) new XElement ("k", double.MaxValue), "MaxValue:double?");
+			Assert.AreEqual (double.MinValue, (double?) new XElement ("k", double.MinValue), "MinValue:double?");
+			Assert.AreEqual (double.Epsilon, (double?) new XElement ("k", double.Epsilon), "Epsilon:double?");
+			Assert.AreEqual (double.NaN, (double?) new XElement ("k", double.NaN), "NaN:double?");
+			Assert.AreEqual (double.NegativeInfinity, (double?) new XElement ("k", double.NegativeInfinity), "-Inf:double?");
+			Assert.AreEqual (double.PositiveInfinity, (double?) new XElement ("k", double.PositiveInfinity), "+Inf:double?");
+			Assert.AreEqual (float.MaxValue, (float?) new XElement ("k", float.MaxValue), "MaxValue:float?");
+			Assert.AreEqual (float.MinValue, (float?) new XElement ("k", float.MinValue), "MinValue:float?");
+			Assert.AreEqual (float.Epsilon, (float?) new XElement ("k", float.Epsilon), "Epsilon:float?");
+			Assert.AreEqual (float.NaN, (float?) new XElement ("k", float.NaN), "NaN:float?");
+			Assert.AreEqual (float.NegativeInfinity, (float?) new XElement ("k", float.NegativeInfinity), "-Inf:float?");
+			Assert.AreEqual (float.PositiveInfinity, (float?) new XElement ("k", float.PositiveInfinity), "+Inf:float?");
+			Assert.AreEqual (int.MaxValue, (int?) new XElement ("k", int.MaxValue), "MaxValue:int?");
+			Assert.AreEqual (int.MinValue, (int?) new XElement ("k", int.MinValue), "MinValue:int?");
+			Assert.AreEqual (long.MaxValue, (long?) new XElement ("k", long.MaxValue), "MaxValue:long?");
+			Assert.AreEqual (long.MinValue, (long?) new XElement ("k", long.MinValue), "MinValue:long?");
+			Assert.AreEqual (uint.MaxValue, (uint?) new XElement ("k", uint.MaxValue), "MaxValue:uint?");
+			Assert.AreEqual (uint.MinValue, (uint?) new XElement ("k", uint.MinValue), "MinValue:uint?");
+			Assert.AreEqual (ulong.MaxValue, (ulong?) new XElement ("k", ulong.MaxValue), "MaxValue:ulong?");
+			Assert.AreEqual (ulong.MinValue, (ulong?) new XElement ("k", ulong.MinValue), "MinValue:ulong?");
+			Assert.AreEqual (DateTime.MaxValue, (DateTime) new XElement ("k", DateTime.MaxValue), "MaxValue:DateTime");
+			Assert.AreEqual (DateTime.MinValue, (DateTime) new XElement ("k", DateTime.MinValue), "MinValue:DateTime");
+			Assert.AreEqual (DateTime.MaxValue, (DateTime?) new XElement ("k", DateTime.MaxValue), "MaxValue:DateTime?");
+			Assert.AreEqual (DateTime.MinValue, (DateTime?) new XElement ("k", DateTime.MinValue), "MinValue:DateTime?");
+			Assert.AreEqual (DateTimeOffset.MaxValue, (DateTimeOffset) new XElement ("k", DateTimeOffset.MaxValue), "MaxValue:DateTimeOffset");
+			Assert.AreEqual (DateTimeOffset.MinValue, (DateTimeOffset) new XElement ("k", DateTimeOffset.MinValue), "MinValue:DateTimeOffset");
+			Assert.AreEqual (DateTimeOffset.MaxValue, (DateTimeOffset?) new XElement ("k", DateTimeOffset.MaxValue), "MaxValue:DateTimeOffset?");
+			Assert.AreEqual (DateTimeOffset.MinValue, (DateTimeOffset?) new XElement ("k", DateTimeOffset.MinValue), "MinValue:DateTimeOffset?");
+			Assert.AreEqual (TimeSpan.MaxValue, (TimeSpan) new XElement ("k", TimeSpan.MaxValue), "MaxValue:TimeSpan");
+			Assert.AreEqual (TimeSpan.MinValue, (TimeSpan) new XElement ("k", TimeSpan.MinValue), "MinValue:TimeSpan");
+			Assert.AreEqual (TimeSpan.MaxValue, (TimeSpan?) new XElement ("k", TimeSpan.MaxValue), "MaxValue:TimeSpan?");
+			Assert.AreEqual (TimeSpan.MinValue, (TimeSpan?) new XElement ("k", TimeSpan.MinValue), "MinValue:TimeSpan?");
+		}
+
 		[Test]
 		public void CastBooleans ()
 		{
@@ -1137,6 +1205,10 @@ namespace MonoTests.System.Xml.Linq
 			Assert.IsNotNull ((bool?) new XElement ("x", false), "#16a");
 			Assert.IsFalse (((bool?) new XElement ("x", false)).Value, "#16b");
 			Assert.IsFalse ((bool) new XElement ("x", false), "#16c");
+			Assert.IsTrue ((bool) new XElement ("x", bool.TrueString), "#17a");
+			Assert.IsFalse ((bool) new XElement ("x", bool.FalseString), "#17b");
+			Assert.IsTrue ((bool) new XElement ("x", new XCData (bool.TrueString)), "#18a");
+			Assert.IsFalse ((bool) new XElement ("x", new XCData (bool.FalseString)), "#18b");
 		}
 
 		[Test]

mcs/class/corlib/System/ChangeLog

@@ -1,3 +1,8 @@
+2010-01-25  Atsushi Enomoto  <[email protected]>
+
+	* Single.cs : parse MaxValue and PositiveInfinity as expected.
+	  Patch by Tiaan Geldenhuys.
+
 2010-01-21  Carlos Alberto Cortez <[email protected]>
 
 	* Activator.cs: When calling CreateInstance() and no default .ctor is

mcs/class/corlib/System/Single.cs

@@ -46,6 +46,10 @@ namespace System
 		public const float PositiveInfinity =  1.0f / 0.0f;
 		public const float NegativeInfinity = -1.0f / 0.0f;
 
+		// Maximum allowed rounding-error so that float.MaxValue can round-trip successfully; calculated 
+		// using: (double.Parse (float.MaxValue.ToString ("r")) - (double) float.MaxValue).ToString ("r")
+		private const double MaxValueEpsilon = 3.6147112457961776e29d;
+
 		internal float m_value;
 
 		public int CompareTo (object value)
@@ -166,7 +170,7 @@ namespace System
 		{
 			double parsed_value = Double.Parse (
 				s, (NumberStyles.Float | NumberStyles.AllowThousands), null);
-			if (parsed_value > (double) float.MaxValue)
+			if (parsed_value - (double) float.MaxValue > MaxValueEpsilon && (!double.IsPositiveInfinity (parsed_value)))
 				throw new OverflowException();
 
 			return (float) parsed_value;
@@ -176,7 +180,7 @@ namespace System
 		{
 			double parsed_value = Double.Parse (
 				s, (NumberStyles.Float | NumberStyles.AllowThousands), provider);
-			if (parsed_value > (double) float.MaxValue)
+			if (parsed_value - (double) float.MaxValue > MaxValueEpsilon && (!double.IsPositiveInfinity (parsed_value)))
 				throw new OverflowException();
 
 			return (float) parsed_value;
@@ -185,7 +189,7 @@ namespace System
 		public static float Parse (string s, NumberStyles style)
 		{
 			double parsed_value = Double.Parse (s, style, null);
-			if (parsed_value > (double) float.MaxValue)
+			if (parsed_value - (double) float.MaxValue > MaxValueEpsilon && (!double.IsPositiveInfinity (parsed_value)))
 				throw new OverflowException();
 
 			return (float) parsed_value;
@@ -194,7 +198,7 @@ namespace System
 		public static float Parse (string s, NumberStyles style, IFormatProvider provider) 
 		{
 			double parsed_value = Double.Parse (s, style, provider);
-			if (parsed_value > (double) float.MaxValue)
+			if (parsed_value - (double) float.MaxValue > MaxValueEpsilon && (!double.IsPositiveInfinity (parsed_value)))
 				throw new OverflowException();
 
 			return (float) parsed_value;
@@ -206,7 +210,7 @@ namespace System
 			if (!Double.Parse (s, style, provider, true, out parsed_value, out exc)) {
 				result = 0;
 				return false;
-			} else if (parsed_value > (double) float.MaxValue) {
+			} else if (parsed_value - (double) float.MaxValue > MaxValueEpsilon && (!double.IsPositiveInfinity (parsed_value))) {
 				result = 0;
 				return false;
 			}

mcs/class/corlib/Test/System/ChangeLog

@@ -1,3 +1,8 @@
+2010-01-25  Atsushi Enomoto  <[email protected]>
+
+	* SingleTest.cs : test for parsing MaxValue and PositiveInfinity.
+	  Patch by Tiaan Geldenhuys.
+
 2010-01-19 Rodrigo Kumpera  <[email protected]>
 
 	* TypeTest.cs: Add test for GetGenericMethodDefinition of inflated

mcs/class/corlib/Test/System/SingleTest.cs

@@ -102,12 +102,69 @@ namespace MonoTests.System
 		}
 
 		[Test]
-		[Category ("NotWorking")]
 		public void ToString_Roundtrip ()
 		{
 			Assert.AreEqual (10.78f.ToString ("R", NumberFormatInfo.InvariantInfo), "10.78");
 		}
 
+		[Test]
+		public void Parse_Roundtrip ()
+		{
+			string maxVal = float.MaxValue.ToString ("r");
+			string minVal = float.MinValue.ToString ("r");
+			string epsilon = float.Epsilon.ToString ("r");
+			string nan = float.NaN.ToString ("r");
+			string negInf = float.NegativeInfinity.ToString ("r");
+			string posInf = float.PositiveInfinity.ToString ("r");
+
+			float result;
+			Assert.IsTrue (float.TryParse (maxVal, NumberStyles.Float, CultureInfo.InvariantCulture, out result), "MaxValue#1a");
+			Assert.AreEqual (float.MaxValue, result, "MaxValue#1b");
+			Assert.IsTrue (float.TryParse (minVal, NumberStyles.Float, CultureInfo.InvariantCulture, out result), "MinValue#1a");
+			Assert.AreEqual (float.MinValue, result, "MinValue#1b");
+			Assert.IsTrue (float.TryParse (epsilon, NumberStyles.Float, CultureInfo.InvariantCulture, out result), "Epsilon#1a");
+			Assert.AreEqual (float.Epsilon, result, "Epsilon#1b");
+			Assert.IsTrue (float.TryParse (nan, NumberStyles.Float, CultureInfo.InvariantCulture, out result), "NaN#1a");
+			Assert.AreEqual (float.NaN, result, "NaN#1b");
+			Assert.IsNaN (result, "NaN#1c");
+			Assert.IsTrue (float.TryParse (negInf, NumberStyles.Float, CultureInfo.InvariantCulture, out result), "-Inf#1a");
+			Assert.AreEqual (float.NegativeInfinity, result, "-Inf#1b");
+			Assert.IsTrue (float.TryParse (posInf, NumberStyles.Float, CultureInfo.InvariantCulture, out result), "+Inf#1a");
+			Assert.AreEqual (float.PositiveInfinity, result, "+Inf#1b");
+
+			Assert.AreEqual (float.MaxValue, float.Parse (maxVal), "MaxValue#2");
+			Assert.AreEqual (float.MinValue, float.Parse (minVal), "MinValue#2");
+			Assert.AreEqual (float.Epsilon, float.Parse (epsilon), "Epsilon#2");
+			Assert.AreEqual (float.NaN, float.Parse (nan), "NaN#2a");
+			Assert.IsNaN (float.Parse (nan), "NaN#2b");
+			Assert.AreEqual (float.NegativeInfinity, float.Parse (negInf), "-Inf#2");
+			Assert.AreEqual (float.PositiveInfinity, float.Parse (posInf), "+Inf#2");
+
+			Assert.AreEqual (float.MaxValue, float.Parse (maxVal, CultureInfo.InvariantCulture), "MaxValue#3");
+			Assert.AreEqual (float.MinValue, float.Parse (minVal, CultureInfo.InvariantCulture), "MinValue#3");
+			Assert.AreEqual (float.Epsilon, float.Parse (epsilon, CultureInfo.InvariantCulture), "Epsilon#3");
+			Assert.AreEqual (float.NaN, float.Parse (nan, CultureInfo.InvariantCulture), "NaN#3a");
+			Assert.IsNaN (float.Parse (nan, CultureInfo.InvariantCulture), "NaN#3b");
+			Assert.AreEqual (float.NegativeInfinity, float.Parse (negInf, CultureInfo.InvariantCulture), "-Inf#3");
+			Assert.AreEqual (float.PositiveInfinity, float.Parse (posInf, CultureInfo.InvariantCulture), "+Inf#3");
+
+			Assert.AreEqual (float.MaxValue, float.Parse (maxVal, NumberStyles.Float), "MaxValue#4");
+			Assert.AreEqual (float.MinValue, float.Parse (minVal, NumberStyles.Float), "MinValue#4");
+			Assert.AreEqual (float.Epsilon, float.Parse (epsilon, NumberStyles.Float), "Epsilon#4");
+			Assert.AreEqual (float.NaN, float.Parse (nan, NumberStyles.Float), "NaN#4a");
+			Assert.IsNaN (float.Parse (nan, NumberStyles.Float), "NaN#4b");
+			Assert.AreEqual (float.NegativeInfinity, float.Parse (negInf, NumberStyles.Float), "-Inf#4");
+			Assert.AreEqual (float.PositiveInfinity, float.Parse (posInf, NumberStyles.Float), "+Inf#4");
+
+			Assert.AreEqual (float.MaxValue, float.Parse (maxVal, NumberStyles.Float, CultureInfo.InvariantCulture), "MaxValue#5");
+			Assert.AreEqual (float.MinValue, float.Parse (minVal, NumberStyles.Float, CultureInfo.InvariantCulture), "MinValue#5");
+			Assert.AreEqual (float.Epsilon, float.Parse (epsilon, NumberStyles.Float, CultureInfo.InvariantCulture), "Epsilon#5");
+			Assert.AreEqual (float.NaN, float.Parse (nan, NumberStyles.Float, CultureInfo.InvariantCulture), "NaN#5a");
+			Assert.IsNaN (float.Parse (nan, NumberStyles.Float, CultureInfo.InvariantCulture), "NaN#5b");
+			Assert.AreEqual (float.NegativeInfinity, float.Parse (negInf, NumberStyles.Float, CultureInfo.InvariantCulture), "-Inf#5");
+			Assert.AreEqual (float.PositiveInfinity, float.Parse (posInf, NumberStyles.Float, CultureInfo.InvariantCulture), "+Inf#5");
+		}
+
 #if NET_2_0
 		[Test] // bug #72221
 		[ExpectedException (typeof (ArgumentException))]