projects / mono.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: e139ef1)
Don't throw when trying to parse leading sign number only. Fixes #12008
authorMarek Safar <marek.safar@gmail.com>
Mon, 29 Apr 2013 14:51:34 +0000 (16:51 +0200)
committerMarek Safar <marek.safar@gmail.com>
Mon, 29 Apr 2013 14:51:34 +0000 (16:51 +0200)
mcs/class/corlib/System/Int32.cs patch | blob | history
mcs/class/corlib/System/Int64.cs patch | blob | history
mcs/class/corlib/System/UInt32.cs patch | blob | history
mcs/class/corlib/System/UInt64.cs patch | blob | history
mcs/class/corlib/Test/System/Int32Test.cs patch | blob | history
mcs/class/corlib/Test/System/Int64Test.cs patch | blob | history
mcs/class/corlib/Test/System/UInt32Test.cs patch | blob | history
mcs/class/corlib/Test/System/UInt64Test.cs patch | blob | history

diff --git a/mcs/class/corlib/System/Int32.cs b/mcs/class/corlib/System/Int32.cs
index b78c0a5b14ec32b54a26167defe075bf8f6734db..d49cc8608631106776f3cbee57a76fadf0819a10 100644 (file)
--- a/mcs/class/corlib/System/Int32.cs
+++ b/mcs/class/corlib/System/Int32.cs
@@ -466,7 +466,7 @@ namespace System {
                        char hexDigit;
                                
                        // Number stuff
-                       do {
+                       while (pos < s.Length) {
 
                                if (!ValidDigit (s [pos], AllowHexSpecifier)) {
                                        if (AllowThousands &&
@@ -517,7 +517,7 @@ namespace System {
                                                exc = new OverflowException ("Value too large or too small.");
                                        return false;
                                }
-                       } while (pos < s.Length);
+                       }
 
                        // Post number stuff
                        if (nDigits == 0) {
diff --git a/mcs/class/corlib/System/Int64.cs b/mcs/class/corlib/System/Int64.cs
index 09538f8ea6e59eca30c9301f37bdd7552e96d617..5b1019fdfd7b62416e9acb01822add98ab3b2e79 100644 (file)
--- a/mcs/class/corlib/System/Int64.cs
+++ b/mcs/class/corlib/System/Int64.cs
@@ -298,7 +298,7 @@ namespace System {
                        char hexDigit;
                                
                        // Number stuff
-                       do {
+                       while (pos < s.Length) {
 
                                if (!Int32.ValidDigit (s [pos], AllowHexSpecifier)) {
                                        if (AllowThousands &&
@@ -350,7 +350,7 @@ namespace System {
                                                exc = new OverflowException ("Value too large or too small.");
                                        return false;
                                }                               
-                       } while (pos < s.Length);
+                       }
 
                        // Post number stuff
                        if (nDigits == 0) {
diff --git a/mcs/class/corlib/System/UInt32.cs b/mcs/class/corlib/System/UInt32.cs
index f78ee9dbab20297f91be7f9e9db1cd9425a01742..7772d870e615e703e7c9e1ad88045ee77cf9ee29 100644 (file)
--- a/mcs/class/corlib/System/UInt32.cs
+++ b/mcs/class/corlib/System/UInt32.cs
@@ -277,7 +277,7 @@ namespace System
 
                        // Number stuff
                        // Just the same as Int32, but this one adds instead of substract
-                       do {
+                       while (pos < s.Length) {
 
                                if (!Int32.ValidDigit (s [pos], AllowHexSpecifier)) {
                                        if (AllowThousands &&
@@ -325,7 +325,7 @@ namespace System
                                                exc = new OverflowException (Locale.GetText ("Value too large or too small."));
                                        return false;
                                }
-                       } while (pos < s.Length);
+                       }
 
                        // Post number stuff
                        if (nDigits == 0) {
diff --git a/mcs/class/corlib/System/UInt64.cs b/mcs/class/corlib/System/UInt64.cs
index 1ac283149a609796ad3c88d0bbe9b4eb2ec9c3a4..464e23998c1b9b68b17f129d9a1009c881bea08c 100644 (file)
--- a/mcs/class/corlib/System/UInt64.cs
+++ b/mcs/class/corlib/System/UInt64.cs
@@ -300,7 +300,7 @@ namespace System
 
                        // Number stuff
                        // Just the same as Int32, but this one adds instead of substract
-                       do {
+                       while (pos < s.Length) {
 
                                if (!Int32.ValidDigit (s [pos], AllowHexSpecifier)) {
                                        if (AllowThousands &&
@@ -350,7 +350,7 @@ namespace System
                                                exc = new OverflowException (Locale.GetText ("Value too large or too small."));
                                        return false;
                                }
-                       } while (pos < s.Length);
+                       }
 
                        // Post number stuff
                        if (nDigits == 0) {
diff --git a/mcs/class/corlib/Test/System/Int32Test.cs b/mcs/class/corlib/Test/System/Int32Test.cs
index 128cc19790df3809993d52f43a8308e197ea9124..b631a0fa1535c43b21a5ceaccc8b7fcc940eec90 100644 (file)
--- a/mcs/class/corlib/Test/System/Int32Test.cs
+++ b/mcs/class/corlib/Test/System/Int32Test.cs
@@ -391,6 +391,8 @@ public class Int32Test
                Assert.AreEqual (true, Int32.TryParse ("ffffffff", NumberStyles.HexNumber, Nfi, out result));
                Assert.AreEqual (-1, result);
                Assert.AreEqual (false, Int32.TryParse ("100000000", NumberStyles.HexNumber, Nfi, out result));
+               Assert.IsFalse (int.TryParse ("-", NumberStyles.AllowLeadingSign, Nfi, out result));
+               Assert.IsFalse (int.TryParse (Nfi.CurrencySymbol + "-", NumberStyles.AllowLeadingSign | NumberStyles.AllowCurrencySymbol, Nfi, out result));
        }
 
        [Test]  
diff --git a/mcs/class/corlib/Test/System/Int64Test.cs b/mcs/class/corlib/Test/System/Int64Test.cs
index 6ad5e36ce4882974205e66d3965a86824265d52f..3943969c65a7aaeec85d1ffc71d4d3b71355e8c0 100644 (file)
--- a/mcs/class/corlib/Test/System/Int64Test.cs
+++ b/mcs/class/corlib/Test/System/Int64Test.cs
@@ -391,6 +391,66 @@ public class Int64Test
                }
        }
 
+       [Test]
+       public void TestTryParse()
+       {
+               long result;
+
+               Assert.AreEqual (true, long.TryParse (MyString1, out result));
+               Assert.AreEqual (MyInt64_1, result);
+               Assert.AreEqual (true, long.TryParse (MyString2, out result));
+               Assert.AreEqual (MyInt64_2, result);
+               Assert.AreEqual (true, long.TryParse (MyString3, out result));
+               Assert.AreEqual (MyInt64_3, result);
+
+               Assert.AreEqual (true, long.TryParse ("1", out result));
+               Assert.AreEqual (1, result);
+               Assert.AreEqual (true, long.TryParse (" 1", out result));
+               Assert.AreEqual (1, result);
+               Assert.AreEqual (true, long.TryParse ("     1", out result));
+               Assert.AreEqual (1, result);
+               Assert.AreEqual (true, long.TryParse ("1    ", out result));
+               Assert.AreEqual (1, result);
+               Assert.AreEqual (true, long.TryParse ("+1", out result));
+               Assert.AreEqual (1, result);
+               Assert.AreEqual (true, long.TryParse ("-1", out result));
+               Assert.AreEqual (-1, result);
+               Assert.AreEqual (true, long.TryParse ("  -1", out result));
+               Assert.AreEqual (-1, result);
+               Assert.AreEqual (true, long.TryParse ("  -1  ", out result));
+               Assert.AreEqual (-1, result);
+               Assert.AreEqual (true, long.TryParse ("  -1  ", out result));
+               Assert.AreEqual (-1, result);
+
+               result = 1;
+               Assert.AreEqual (false, long.TryParse (null, out result));
+               Assert.AreEqual (0, result);
+
+               Assert.AreEqual (false, long.TryParse ("not-a-number", out result));
+
+               double OverInt = (double)long.MaxValue + 1;
+               Assert.AreEqual (false, long.TryParse (OverInt.ToString (), out result));
+               Assert.AreEqual (false, long.TryParse (OverInt.ToString (), NumberStyles.None, CultureInfo.InvariantCulture, out result));
+
+               Assert.AreEqual (false, long.TryParse ("$42", NumberStyles.Integer, null, out result));
+               Assert.AreEqual (false, long.TryParse ("%42", NumberStyles.Integer, Nfi, out result));
+               Assert.AreEqual (false, long.TryParse ("$42", NumberStyles.Integer, Nfi, out result));
+               Assert.AreEqual (false, long.TryParse (" - 1 ", out result));
+               Assert.AreEqual (false, long.TryParse (" - ", out result));
+               Assert.AreEqual (true, long.TryParse ("100000000", NumberStyles.HexNumber, Nfi, out result));
+               Assert.AreEqual (true, long.TryParse ("10000000000", out result));
+               Assert.AreEqual (true, long.TryParse ("-10000000000", out result));
+               Assert.AreEqual (true, long.TryParse ("7fffffff", NumberStyles.HexNumber, Nfi, out result));
+               Assert.AreEqual (int.MaxValue, result);
+               Assert.AreEqual (true, long.TryParse ("80000000", NumberStyles.HexNumber, Nfi, out result));
+               Assert.AreEqual (2147483648, result);
+               Assert.AreEqual (true, long.TryParse ("ffffffff", NumberStyles.HexNumber, Nfi, out result));
+               Assert.AreEqual (uint.MaxValue, result);
+               Assert.AreEqual (true, long.TryParse ("100000000", NumberStyles.HexNumber, Nfi, out result));
+               Assert.IsFalse (long.TryParse ("-", NumberStyles.AllowLeadingSign, Nfi, out result));
+               Assert.IsFalse (long.TryParse (Nfi.CurrencySymbol + "-", NumberStyles.AllowLeadingSign | NumberStyles.AllowCurrencySymbol, Nfi, out result));
+       }       
+
        [Test]
     public void TestToString() 
     {
diff --git a/mcs/class/corlib/Test/System/UInt32Test.cs b/mcs/class/corlib/Test/System/UInt32Test.cs
index 20f5a299e36fdf12f742ee4c953dde0a8f9f90e6..6a730d2c737077283d0b59d656995aaa7166a91c 100644 (file)
--- a/mcs/class/corlib/Test/System/UInt32Test.cs
+++ b/mcs/class/corlib/Test/System/UInt32Test.cs
@@ -275,6 +275,62 @@ public class UInt32Test
                }
        }
 
+       [Test]
+       public void TestTryParse()
+       {
+               uint result;
+
+               Assert.AreEqual (true, UInt32.TryParse (MyString1, out result));
+               Assert.AreEqual (MyUInt32_1, result);
+               Assert.AreEqual (true, UInt32.TryParse (MyString2, out result));
+               Assert.AreEqual (MyUInt32_2, result);
+               Assert.AreEqual (true, UInt32.TryParse (MyString3, out result));
+               Assert.AreEqual (MyUInt32_3, result);
+
+               Assert.AreEqual (true, UInt32.TryParse ("1", out result));
+               Assert.AreEqual (1, result);
+               Assert.AreEqual (true, UInt32.TryParse (" 1", out result));
+               Assert.AreEqual (1, result);
+               Assert.AreEqual (true, UInt32.TryParse ("     1", out result));
+               Assert.AreEqual (1, result);
+               Assert.AreEqual (true, UInt32.TryParse ("1    ", out result));
+               Assert.AreEqual (1, result);
+               Assert.AreEqual (true, UInt32.TryParse ("+1", out result));
+               Assert.AreEqual (1, result);
+               Assert.AreEqual (false, UInt32.TryParse ("-1", out result));
+               Assert.AreEqual (false, UInt32.TryParse ("  -1", out result));
+               Assert.AreEqual (false, UInt32.TryParse ("  -1  ", out result));
+               Assert.AreEqual (false, UInt32.TryParse ("  -1  ", out result));
+
+               result = 1;
+               Assert.AreEqual (false, UInt32.TryParse (null, out result));
+               Assert.AreEqual (0, result);
+
+               Assert.AreEqual (false, UInt32.TryParse ("not-a-number", out result));
+
+               double OverInt = (double)UInt32.MaxValue + 1;
+               Assert.AreEqual (false, UInt32.TryParse (OverInt.ToString (), out result));
+               Assert.AreEqual (false, UInt32.TryParse (OverInt.ToString (), NumberStyles.None, CultureInfo.InvariantCulture, out result));
+
+               Assert.AreEqual (false, UInt32.TryParse ("$42", NumberStyles.Integer, null, out result));
+               Assert.AreEqual (false, UInt32.TryParse ("%42", NumberStyles.Integer, Nfi, out result));
+               Assert.AreEqual (false, UInt32.TryParse ("$42", NumberStyles.Integer, Nfi, out result));
+               Assert.AreEqual (false, UInt32.TryParse (" - 1 ", out result));
+               Assert.AreEqual (false, UInt32.TryParse (" - ", out result));
+               Assert.AreEqual (true, UInt32.TryParse ("100000000", NumberStyles.HexNumber, Nfi, out result));
+               Assert.AreEqual (false, UInt32.TryParse ("10000000000", out result));
+               Assert.AreEqual (false, UInt32.TryParse ("-10000000000", out result));
+               Assert.AreEqual (true, UInt32.TryParse ("7fffffff", NumberStyles.HexNumber, Nfi, out result));
+               Assert.AreEqual (Int32.MaxValue, result);
+               Assert.AreEqual (true, UInt32.TryParse ("80000000", NumberStyles.HexNumber, Nfi, out result));
+               Assert.AreEqual (Int32.MaxValue + (uint)1, result);
+               Assert.AreEqual (true, UInt32.TryParse ("ffffffff", NumberStyles.HexNumber, Nfi, out result));
+               Assert.AreEqual (uint.MaxValue, result);
+               Assert.AreEqual (true, UInt32.TryParse ("100000000", NumberStyles.HexNumber, Nfi, out result));
+               Assert.IsFalse (uint.TryParse ("-", NumberStyles.AllowLeadingSign, Nfi, out result));
+               Assert.IsFalse (uint.TryParse (Nfi.CurrencySymbol + "-", NumberStyles.AllowLeadingSign | NumberStyles.AllowCurrencySymbol, Nfi, out result));
+       }       
+
        [Test]
        public void TestToString()
        {
diff --git a/mcs/class/corlib/Test/System/UInt64Test.cs b/mcs/class/corlib/Test/System/UInt64Test.cs
index 3fbf591517be0614e35ca171d86b9f9f8a93d612..dda949c4022e60f899aa78fa0f417d912497ee0c 100644 (file)
--- a/mcs/class/corlib/Test/System/UInt64Test.cs
+++ b/mcs/class/corlib/Test/System/UInt64Test.cs
@@ -264,6 +264,62 @@ public class UInt64Test
                }
        }
 
+       [Test]
+       public void TestTryParse()
+       {
+               ulong result;
+
+               Assert.AreEqual (true, ulong.TryParse (MyString1, out result));
+               Assert.AreEqual (MyUInt64_1, result);
+               Assert.AreEqual (true, ulong.TryParse (MyString2, out result));
+               Assert.AreEqual (MyUInt64_2, result);
+               Assert.AreEqual (true, ulong.TryParse (MyString3, out result));
+               Assert.AreEqual (MyUInt64_3, result);
+
+               Assert.AreEqual (true, ulong.TryParse ("1", out result));
+               Assert.AreEqual (1, result);
+               Assert.AreEqual (true, ulong.TryParse (" 1", out result));
+               Assert.AreEqual (1, result);
+               Assert.AreEqual (true, ulong.TryParse ("     1", out result));
+               Assert.AreEqual (1, result);
+               Assert.AreEqual (true, ulong.TryParse ("1    ", out result));
+               Assert.AreEqual (1, result);
+               Assert.AreEqual (true, ulong.TryParse ("+1", out result));
+               Assert.AreEqual (1, result);
+               Assert.AreEqual (false, ulong.TryParse ("-1", out result));
+               Assert.AreEqual (false, ulong.TryParse ("  -1", out result));
+               Assert.AreEqual (false, ulong.TryParse ("  -1  ", out result));
+               Assert.AreEqual (false, ulong.TryParse ("  -1  ", out result));
+
+               result = 1;
+               Assert.AreEqual (false, ulong.TryParse (null, out result));
+               Assert.AreEqual (0, result);
+
+               Assert.AreEqual (false, ulong.TryParse ("not-a-number", out result));
+
+               double OverInt = (double)ulong.MaxValue + 1;
+               Assert.AreEqual (false, ulong.TryParse (OverInt.ToString (), out result));
+               Assert.AreEqual (false, ulong.TryParse (OverInt.ToString (), NumberStyles.None, CultureInfo.InvariantCulture, out result));
+
+               Assert.AreEqual (false, ulong.TryParse ("$42", NumberStyles.Integer, null, out result));
+               Assert.AreEqual (false, ulong.TryParse ("%42", NumberStyles.Integer, Nfi, out result));
+               Assert.AreEqual (false, ulong.TryParse ("$42", NumberStyles.Integer, Nfi, out result));
+               Assert.AreEqual (false, ulong.TryParse (" - 1 ", out result));
+               Assert.AreEqual (false, ulong.TryParse (" - ", out result));
+               Assert.AreEqual (true, ulong.TryParse ("100000000", NumberStyles.HexNumber, Nfi, out result));
+               Assert.AreEqual (true, ulong.TryParse ("10000000000", out result));
+               Assert.AreEqual (false, ulong.TryParse ("-10000000000", out result));
+               Assert.AreEqual (true, ulong.TryParse ("7fffffff", NumberStyles.HexNumber, Nfi, out result));
+               Assert.AreEqual (int.MaxValue, result);
+               Assert.AreEqual (true, ulong.TryParse ("80000000", NumberStyles.HexNumber, Nfi, out result));
+               Assert.AreEqual (2147483648, result);
+               Assert.AreEqual (true, ulong.TryParse ("ffffffff", NumberStyles.HexNumber, Nfi, out result));
+               Assert.AreEqual (uint.MaxValue, result);
+               Assert.AreEqual (true, ulong.TryParse ("100000000", NumberStyles.HexNumber, Nfi, out result));
+               Assert.IsFalse (ulong.TryParse ("-", NumberStyles.AllowLeadingSign, Nfi, out result));
+               Assert.IsFalse (ulong.TryParse (Nfi.CurrencySymbol + "-", NumberStyles.AllowLeadingSign | NumberStyles.AllowCurrencySymbol, Nfi, out result));
+       }       
+
        [Test]
        public void TestToString()
        {
my mono mirror. check out Moved to http://github.com/mono/mono