[corlib] Make primitive types smaller than int compare result compatible

[mono.git] / mcs / class / corlib / Test / System / Int16Test.cs

diff --git a/mcs/class/corlib/Test/System/Int16Test.cs b/mcs/class/corlib/Test/System/Int16Test.cs
index c01514e219e9d1221a5970b0f641962b76101ade..93317046963230c0fed81c4b0bbb9fd69e41949a 100644 (file)
--- a/mcs/class/corlib/Test/System/Int16Test.cs
+++ b/mcs/class/corlib/Test/System/Int16Test.cs
@@ -71,16 +71,14 @@ public class Int16Test
        [Test]  
        public void TestCompareTo()
        {
-               Assert.IsTrue(MyInt16_3.CompareTo(MyInt16_2) > 0);
-               Assert.IsTrue(MyInt16_2.CompareTo(MyInt16_2) == 0);
-               Assert.IsTrue(MyInt16_1.CompareTo((Int16)(-42)) == 0);
-               Assert.IsTrue(MyInt16_2.CompareTo(MyInt16_3) < 0);
+               Assert.AreEqual(65535, MyInt16_3.CompareTo(MyInt16_2), "#1");
+               Assert.AreEqual(0, MyInt16_2.CompareTo(MyInt16_2), "#2");
+               Assert.AreEqual(0, MyInt16_1.CompareTo((Int16)(-42)), "#3");
+               Assert.AreEqual(-65535, MyInt16_2.CompareTo(MyInt16_3), "#4");
                try {
                        MyInt16_2.CompareTo((object)100);
                        Assert.Fail ("Should raise a System.ArgumentException");
-               }
-               catch (Exception e) {
-                       Assert.IsTrue(typeof(ArgumentException) == e.GetType());
+               } catch (ArgumentException e) {
                }
        }
 
@@ -163,10 +161,71 @@ public class Int16Test
                        Assert.IsTrue(typeof(FormatException) == e.GetType());
                }
 
-               Assert.AreEqual (7345, Int64.Parse ("7345\0"), "#1");
-               Assert.AreEqual (7345, Int64.Parse ("7345\0\0\0    \0"), "#2");
-               Assert.AreEqual (7345, Int64.Parse ("7345\0\0\0    "), "#3");
-               Assert.AreEqual (7345, Int64.Parse ("7345\0\0\0"), "#4");
+               Assert.AreEqual (7345, Int16.Parse ("7345\0"), "#1");
+               Assert.AreEqual (7345, Int16.Parse ("7345\0\0\0    \0"), "#2");
+               Assert.AreEqual (7345, Int16.Parse ("7345\0\0\0    "), "#3");
+               Assert.AreEqual (7345, Int16.Parse ("7345\0\0\0"), "#4");
+
+               Assert.AreEqual (0, Int16.Parse ("0+", NumberStyles.Any), "#5");
+       }
+
+       [Test]
+       public void TestParseExponent ()
+       {
+               Assert.AreEqual (2, Int16.Parse ("2E0", NumberStyles.AllowExponent), "A#1");
+               Assert.AreEqual (20, Int16.Parse ("2E1", NumberStyles.AllowExponent), "A#2");
+               Assert.AreEqual (200, Int16.Parse ("2E2", NumberStyles.AllowExponent), "A#3");
+               Assert.AreEqual (200, Int16.Parse ("2E+2", NumberStyles.AllowExponent), "A#4");
+               Assert.AreEqual (2, Int16.Parse ("2", NumberStyles.AllowExponent), "A#5");
+
+               try {
+                       Int16.Parse ("2E");
+                       Assert.Fail ("B#1");
+               } catch (FormatException) {
+               }
+
+               try {
+                       Int16.Parse ("2E3.0", NumberStyles.AllowExponent); // decimal notation for the exponent
+                       Assert.Fail ("B#2");
+               } catch (FormatException) {
+               }
+
+               try {
+                       Int16.Parse ("2E 2", NumberStyles.AllowExponent);
+                       Assert.Fail ("B#3");
+               } catch (FormatException) {
+               }
+
+               try {
+                       Int16.Parse ("2E2 ", NumberStyles.AllowExponent);
+                       Assert.Fail ("B#4");
+               } catch (FormatException) {
+               }
+
+               try {
+                       Int16.Parse ("2E66", NumberStyles.AllowExponent); // final result overflow
+                       Assert.Fail ("B#5");
+               } catch (OverflowException) {
+               }
+
+               try {
+                       long exponent = (long) Int32.MaxValue + 10;
+                       Int16.Parse ("2E" + exponent.ToString (), NumberStyles.AllowExponent);
+                       Assert.Fail ("B#6");
+               } catch (OverflowException) {
+               }
+
+               try {
+                       Int16.Parse ("2E-1", NumberStyles.AllowExponent); // negative exponent
+                       Assert.Fail ("B#7");
+               } catch (OverflowException) {
+               }
+               
+               try {
+                       Int16.Parse ("2 math e1", NumberStyles.AllowExponent);
+                       Assert.Fail ("B#8");
+               } catch (FormatException) {
+               }
        }
 
        [Test]
@@ -222,6 +281,12 @@ public class Int16Test
 
                Assert.AreEqual ("254", def, "ToString(G)");
        }
+
+       [Test]
+       public void Bug3677 ()
+       {
+               Assert.AreEqual (-7197, short.Parse("E3E3", NumberStyles.HexNumber), "HexNumber");
+       }
 }
 
 }