--- /dev/null
+//\r
+// SqlDateTimeTest.cs - NUnit Test Cases for System.Data.SqlTypes.SqlDateTime\r
+//\r
+// Ville Palo (vi64pa@koti.soon.fi)\r
+//\r
+// (C) Ville Palo 2002\r
+// \r
+\r
+using NUnit.Framework;\r
+using System;\r
+using System.Data.SqlTypes;\r
+\r
+namespace MonoTests.System.Data.SqlTypes\r
+{\r
+ public class SqlDateTimeTest : TestCase {\r
+\r
+ private long[] myTicks = {\r
+ 631501920000000000L, // 25 Feb 2002 - 00:00:00\r
+ 631502475130080000L, // 25 Feb 2002 - 15:25:13,8\r
+ 631502115130080000L, // 25 Feb 2002 - 05:25:13,8\r
+ 631502115000000000L, // 25 Feb 2002 - 05:25:00\r
+ 631502115130000000L, // 25 Feb 2002 - 05:25:13\r
+ 631502079130000000L, // 25 Feb 2002 - 04:25:13\r
+ 629197085770000000L // 06 Nov 1994 - 08:49:37 \r
+ };\r
+\r
+ private SqlDateTime Test1;\r
+ private SqlDateTime Test2;\r
+ private SqlDateTime Test3;\r
+\r
+ public SqlDateTimeTest() : base ("System.Data.SqlTypes.SqlDateTime") {}\r
+ public SqlDateTimeTest(string name) : base(name) {}\r
+\r
+ protected override void TearDown() {}\r
+\r
+ protected override void SetUp() \r
+ {\r
+ Test1 = new SqlDateTime (2002, 10, 19, 9, 40, 0);\r
+ Test2 = new SqlDateTime (2003, 11, 20,10, 50, 1);\r
+ Test3 = new SqlDateTime (2003, 11, 20, 10, 50, 1);\r
+ }\r
+\r
+ public static ITest Suite {\r
+ get {\r
+ return new TestSuite(typeof(SqlDateTime));\r
+ }\r
+ }\r
+\r
+ // Test constructor\r
+ public void TestCreate()\r
+ {\r
+ // SqlDateTime (DateTime)\r
+ SqlDateTime CTest = new SqlDateTime (\r
+ new DateTime (2002, 5, 19, 3, 34, 0));\r
+ AssertEquals ("#A01", 2002, CTest.Value.Year);\r
+ \r
+ // SqlDateTime (int, int)\r
+ CTest = new SqlDateTime (0, 0);\r
+ \r
+ // SqlDateTime (int, int, int)\r
+ AssertEquals ("#A02", 1900, CTest.Value.Year);\r
+ AssertEquals ("#A03", 1, CTest.Value.Month);\r
+ AssertEquals ("#A04", 1, CTest.Value.Day);\r
+ AssertEquals ("#A05", 0, CTest.Value.Hour);\r
+\r
+ // SqlDateTime (int, int, int, int, int, int)\r
+ CTest = new SqlDateTime (5000, 12, 31);\r
+ AssertEquals ("#A06", 5000, CTest.Value.Year);\r
+ AssertEquals ("#A07", 12, CTest.Value.Month);\r
+ AssertEquals ("#A08", 31, CTest.Value.Day);\r
+\r
+ // SqlDateTime (int, int, int, int, int, int, double)\r
+ CTest = new SqlDateTime (1978, 5, 19, 3, 34, 0);\r
+ AssertEquals ("#A09", 1978, CTest.Value.Year);\r
+ AssertEquals ("#A10", 5, CTest.Value.Month);\r
+ AssertEquals ("#A11", 19, CTest.Value.Day);\r
+ AssertEquals ("#A12", 3, CTest.Value.Hour);\r
+ AssertEquals ("#A13", 34, CTest.Value.Minute);\r
+ AssertEquals ("#A14", 0, CTest.Value.Second);\r
+ \r
+ try {\r
+ CTest = new SqlDateTime (10000, 12, 31);\r
+ Fail ("#A15");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#A16", typeof (SqlTypeException),\r
+ e.GetType ());\r
+ }\r
+ \r
+ // SqlDateTime (int, int, int, int, int, int, int)\r
+ CTest = new SqlDateTime (1978, 5, 19, 3, 34, 0, 12);\r
+ AssertEquals ("#A17", 1978, CTest.Value.Year);\r
+ AssertEquals ("#A18", 5, CTest.Value.Month);\r
+ AssertEquals ("#A19", 19, CTest.Value.Day);\r
+ AssertEquals ("#A20", 3, CTest.Value.Hour);\r
+ AssertEquals ("#A21", 34, CTest.Value.Minute);\r
+ AssertEquals ("#A22", 0, CTest.Value.Second);\r
+ AssertEquals ("#A23", 0, CTest.Value.Millisecond);\r
+ }\r
+\r
+ // Test public fields\r
+ public void TestPublicFields()\r
+ {\r
+ // MaxValue\r
+ AssertEquals ("#B01", 9999, SqlDateTime.MaxValue.Value.Year);\r
+ AssertEquals ("#B02", 12, SqlDateTime.MaxValue.Value.Month);\r
+ AssertEquals ("#B03", 31, SqlDateTime.MaxValue.Value.Day);\r
+ AssertEquals ("#B04", 23, SqlDateTime.MaxValue.Value.Hour);\r
+ AssertEquals ("#B05", 59, SqlDateTime.MaxValue.Value.Minute);\r
+ AssertEquals ("#B06", 59, SqlDateTime.MaxValue.Value.Second);\r
+\r
+ // MinValue\r
+ AssertEquals ("#B07", 1753, SqlDateTime.MinValue.Value.Year);\r
+ AssertEquals ("#B08", 1, SqlDateTime.MinValue.Value.Month);\r
+ AssertEquals ("#B09", 1, SqlDateTime.MinValue.Value.Day);\r
+ AssertEquals ("#B10", 0, SqlDateTime.MinValue.Value.Hour);\r
+ AssertEquals ("#B11", 0, SqlDateTime.MinValue.Value.Minute);\r
+ AssertEquals ("#B12", 0, SqlDateTime.MinValue.Value.Second);\r
+\r
+ // Null\r
+ Assert ("#B13", SqlDateTime.Null.IsNull);\r
+\r
+ // SQLTicksPerHour\r
+ AssertEquals ("#B14", 1080000, SqlDateTime.SQLTicksPerHour);\r
+\r
+ // SQLTicksPerMinute\r
+ AssertEquals ("#B15", 18000, SqlDateTime.SQLTicksPerMinute);\r
+\r
+ // SQLTicksPerSecond\r
+ AssertEquals ("#B16", 300, SqlDateTime.SQLTicksPerSecond);\r
+ }\r
+\r
+ // Test properties\r
+ public void TestProperties()\r
+ {\r
+ // DayTicks\r
+ AssertEquals ("#C01", 37546, Test1.DayTicks);\r
+ \r
+ try {\r
+ int test = SqlDateTime.Null.DayTicks;\r
+ Fail ("#C02");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#C03", typeof (SqlNullValueException), \r
+ e.GetType ());\r
+ }\r
+ \r
+ // IsNull\r
+ Assert ("#C04", SqlDateTime.Null.IsNull);\r
+ Assert ("#C05", !Test2.IsNull);\r
+\r
+ // TimeTicks\r
+ AssertEquals ("#C06", 10440000, Test1.TimeTicks);\r
+ \r
+ try {\r
+ int test = SqlDateTime.Null.TimeTicks;\r
+ Fail ("#C07");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#C08", typeof (SqlNullValueException), \r
+ e.GetType ());\r
+ }\r
+\r
+ // Value\r
+ AssertEquals ("#C09", 2003, Test2.Value.Year);\r
+ AssertEquals ("#C10", 2002, Test1.Value.Year); \r
+ }\r
+\r
+ // PUBLIC METHODS\r
+\r
+ public void TestCompareTo()\r
+ {\r
+ SqlString TestString = new SqlString ("This is a test");\r
+\r
+ Assert ("#D01", Test1.CompareTo (Test3) < 0);\r
+ Assert ("#D02", Test2.CompareTo (Test1) > 0);\r
+ Assert ("#D03", Test2.CompareTo (Test3) == 0);\r
+ Assert ("#D04", Test1.CompareTo (SqlDateTime.Null) > 0);\r
+\r
+ try {\r
+ Test1.CompareTo (TestString);\r
+ Fail("#D05");\r
+ } catch(Exception e) {\r
+ AssertEquals ("#D06", typeof (ArgumentException), e.GetType ());\r
+ }\r
+ }\r
+\r
+ public void TestEqualsMethods()\r
+ {\r
+ Assert ("#E01", !Test1.Equals (Test2));\r
+ Assert ("#E03", !Test2.Equals (new SqlString ("TEST")));\r
+ Assert ("#E04", Test2.Equals (Test3));\r
+\r
+ // Static Equals()-method\r
+ Assert ("#E05", SqlDateTime.Equals (Test2, Test3).Value);\r
+ Assert ("#E06", !SqlDateTime.Equals (Test1, Test2).Value);\r
+ }\r
+\r
+ public void TestGetHashCode()\r
+ {\r
+ // FIXME: Better way to test HashCode\r
+ AssertEquals ("#F01", Test1.GetHashCode (), Test1.GetHashCode ());\r
+ Assert ("#F02", Test2.GetHashCode () != Test1.GetHashCode ());\r
+ }\r
+\r
+ public void TestGetType()\r
+ {\r
+ AssertEquals ("#G01", "System.Data.SqlTypes.SqlDateTime", \r
+ Test1.GetType ().ToString ());\r
+ AssertEquals ("#G02", "System.DateTime", \r
+ Test1.Value.GetType ().ToString ());\r
+ }\r
+\r
+ public void TestGreaters()\r
+ {\r
+ // GreateThan ()\r
+ Assert ("#H01", !SqlDateTime.GreaterThan (Test1, Test2).Value);\r
+ Assert ("#H02", SqlDateTime.GreaterThan (Test2, Test1).Value);\r
+ Assert ("#H03", !SqlDateTime.GreaterThan (Test2, Test3).Value);\r
+\r
+ // GreaterTharOrEqual ()\r
+ Assert ("#H04", !SqlDateTime.GreaterThanOrEqual (Test1, Test2).Value);\r
+ Assert ("#H05", SqlDateTime.GreaterThanOrEqual (Test2, Test1).Value);\r
+ Assert ("#H06", SqlDateTime.GreaterThanOrEqual (Test2, Test3).Value);\r
+ }\r
+\r
+ public void TestLessers()\r
+ {\r
+ // LessThan()\r
+ Assert ("#I01", !SqlDateTime.LessThan (Test2, Test3).Value);\r
+ Assert ("#I02", !SqlDateTime.LessThan (Test2, Test1).Value);\r
+ Assert ("#I03", SqlDateTime.LessThan (Test1, Test3).Value);\r
+\r
+ // LessThanOrEqual ()\r
+ Assert ("#I04", SqlDateTime.LessThanOrEqual (Test1, Test2).Value);\r
+ Assert ("#I05", !SqlDateTime.LessThanOrEqual (Test2, Test1).Value);\r
+ Assert ("#I06", SqlDateTime.LessThanOrEqual (Test3, Test2).Value);\r
+ Assert ("#I07", SqlDateTime.LessThanOrEqual (Test1, SqlDateTime.Null).IsNull);\r
+ }\r
+\r
+ public void TestNotEquals()\r
+ {\r
+ Assert ("#J01", SqlDateTime.NotEquals (Test1, Test2).Value);\r
+ Assert ("#J02", SqlDateTime.NotEquals (Test3, Test1).Value);\r
+ Assert ("#J03", !SqlDateTime.NotEquals (Test2, Test3).Value);\r
+ Assert ("#J04", SqlDateTime.NotEquals (SqlDateTime.Null, Test2).IsNull);\r
+ }\r
+\r
+ public void TestParse()\r
+ {\r
+ try {\r
+ SqlDateTime.Parse (null);\r
+ Fail ("#K01");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#K02", typeof (ArgumentNullException), \r
+ e.GetType ());\r
+ }\r
+\r
+ try {\r
+ SqlDateTime.Parse ("not-a-number");\r
+ Fail ("#K03");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#K04", typeof (FormatException), \r
+ e.GetType ());\r
+ }\r
+\r
+ SqlDateTime t1 = SqlDateTime.Parse ("02/25/2002");\r
+ AssertEquals ("#K05", myTicks[0], t1.Value.Ticks);\r
+\r
+ try {\r
+ t1 = SqlDateTime.Parse ("2002-02-25");\r
+ } catch (Exception e) {\r
+ Fail ("#K06 " + e);\r
+ }\r
+\r
+ // Thanks for Martin Baulig for these (DateTimeTest.cs)\r
+ AssertEquals ("#K07", myTicks[0], t1.Value.Ticks);\r
+ t1 = SqlDateTime.Parse ("Monday, 25 February 2002");\r
+ AssertEquals ("#K08", myTicks[0], t1.Value.Ticks);\r
+ t1 = SqlDateTime.Parse ("Monday, 25 February 2002 05:25");\r
+ AssertEquals ("#K09", myTicks[3], t1.Value.Ticks);\r
+ t1 = SqlDateTime.Parse ("Monday, 25 February 2002 05:25:13");\r
+ AssertEquals ("#K10", myTicks[4], t1.Value.Ticks);\r
+ t1 = SqlDateTime.Parse ("02/25/2002 05:25");\r
+ AssertEquals ("#K11", myTicks[3], t1.Value.Ticks);\r
+ t1 = SqlDateTime.Parse ("02/25/2002 05:25:13");\r
+ AssertEquals ("#K12", myTicks[4], t1.Value.Ticks);\r
+ t1 = SqlDateTime.Parse ("2002-02-25 04:25:13Z");\r
+ t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1.Value);\r
+ AssertEquals ("#K13", 2002, t1.Value.Year);\r
+ AssertEquals ("#K14", 02, t1.Value.Month);\r
+ AssertEquals ("#K15", 25, t1.Value.Day);\r
+ AssertEquals ("#K16", 04, t1.Value.Hour);\r
+ AssertEquals ("#K17", 25, t1.Value.Minute);\r
+ AssertEquals ("#K18", 13, t1.Value.Second);\r
+ \r
+ SqlDateTime t2 = new SqlDateTime (DateTime.Today.Year, 2, 25);\r
+ t1 = SqlDateTime.Parse ("February 25");\r
+ AssertEquals ("#K19", t2.Value.Ticks, t1.Value.Ticks);\r
+ \r
+ t2 = new SqlDateTime (DateTime.Today.Year, 2, 8);\r
+ t1 = SqlDateTime.Parse ("February 08");\r
+ AssertEquals ("#K20", t2.Value.Ticks, t1.Value.Ticks);\r
+\r
+ t1 = SqlDateTime.Parse ("Mon, 25 Feb 2002 04:25:13 GMT");\r
+ t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1.Value);\r
+ AssertEquals ("#K21", 2002, t1.Value.Year);\r
+ AssertEquals ("#K22", 02, t1.Value.Month);\r
+ AssertEquals ("#K23", 25, t1.Value.Day);\r
+ AssertEquals ("#K24", 04, t1.Value.Hour);\r
+ AssertEquals ("#K25", 25, t1.Value.Minute);\r
+ AssertEquals ("#K26", 13, t1.Value.Second);\r
+\r
+ t1 = SqlDateTime.Parse ("2002-02-25T05:25:13");\r
+ AssertEquals ("#K27", myTicks[4], t1.Value.Ticks);\r
+\r
+ t2 = DateTime.Today + new TimeSpan (5,25,0);\r
+ t1 = SqlDateTime.Parse ("05:25");\r
+ AssertEquals("#K28", t2.Value.Ticks, t1.Value.Ticks);\r
+\r
+ t2 = DateTime.Today + new TimeSpan (5,25,13);\r
+ t1 = SqlDateTime.Parse ("05:25:13");\r
+ AssertEquals("#K29", t2.Value.Ticks, t1.Value.Ticks);\r
+\r
+ t2 = new SqlDateTime (2002, 2, 1);\r
+ t1 = SqlDateTime.Parse ("2002 February");\r
+ AssertEquals ("#K30", t2.Value.Ticks, t1.Value.Ticks);\r
+ \r
+ t2 = new SqlDateTime (2002, 2, 1);\r
+ t1 = SqlDateTime.Parse ("2002 February");\r
+ AssertEquals ("#K31", t2.Value.Ticks, t1.Value.Ticks);\r
+ \r
+ t2 = new SqlDateTime (DateTime.Today.Year, 2, 8);\r
+ t1 = SqlDateTime.Parse ("February 8");\r
+ \r
+ AssertEquals ("#K32", t2.Value.Ticks, t1.Value.Ticks);\r
+ }\r
+\r
+ public void TestToString()\r
+ {\r
+ //\r
+ // Thanks for Marting Baulig for these (DateTimeTest.cs)\r
+ //\r
+ \r
+ SqlDateTime t1 = new SqlDateTime (2002, 2, 25, 5, 25, 13);\r
+ SqlDateTime t2 = new SqlDateTime (2002, 2, 25, 15, 25, 13);\r
+ \r
+ // Standard patterns\r
+ AssertEquals("L01", "25.2.2002 5:25:13", t1.ToString ());\r
+ AssertEquals("L02", (SqlString)"25.2.2002 5:25:13", t1.ToSqlString ());\r
+ }\r
+\r
+ // OPERATORS\r
+\r
+ public void TestArithmeticOperators()\r
+ {\r
+ TimeSpan TestSpan = new TimeSpan (20, 1, 20, 20);\r
+ SqlDateTime ResultDateTime;\r
+\r
+ // "+"-operator\r
+ ResultDateTime = Test1 + TestSpan;\r
+ AssertEquals ("#M01", 2002, ResultDateTime.Value.Year);\r
+ AssertEquals ("#M02", 8, ResultDateTime.Value.Day);\r
+ AssertEquals ("#M03", 11, ResultDateTime.Value.Hour);\r
+ AssertEquals ("#M04", 0, ResultDateTime.Value.Minute);\r
+ AssertEquals ("#M05", 20, ResultDateTime.Value.Second); \r
+ Assert ("#M06", (SqlDateTime.Null + TestSpan).IsNull);\r
+\r
+ try {\r
+ ResultDateTime = SqlDateTime.MaxValue + TestSpan;\r
+ Fail ("#M07");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#M08", typeof (ArgumentOutOfRangeException), e.GetType ());\r
+ }\r
+\r
+ // "-"-operator\r
+ ResultDateTime = Test1 - TestSpan;\r
+ AssertEquals ("#M09", 2002, ResultDateTime.Value.Year);\r
+ AssertEquals ("#M10", 29, ResultDateTime.Value.Day);\r
+ AssertEquals ("#M11", 8, ResultDateTime.Value.Hour);\r
+ AssertEquals ("#M12", 19, ResultDateTime.Value.Minute);\r
+ AssertEquals ("#M13", 40, ResultDateTime.Value.Second); \r
+ Assert ("#M14", (SqlDateTime.Null - TestSpan).IsNull);\r
+ \r
+ try {\r
+ ResultDateTime = SqlDateTime.MinValue - TestSpan;\r
+ Fail ("#M15");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#M16", typeof (SqlTypeException), e.GetType ());\r
+ }\r
+ }\r
+\r
+ public void TestThanOrEqualOperators()\r
+ {\r
+ // == -operator\r
+ Assert ("#N01", (Test2 == Test3).Value);\r
+ Assert ("#N02", !(Test1 == Test2).Value);\r
+ Assert ("#N03", (Test1 == SqlDateTime.Null).IsNull);\r
+ \r
+ // != -operator\r
+ Assert ("#N04", !(Test2 != Test3).Value);\r
+ Assert ("#N05", (Test1 != Test3).Value);\r
+ Assert ("#N06", (Test1 != SqlDateTime.Null).IsNull);\r
+\r
+ // > -operator\r
+ Assert ("#N07", (Test2 > Test1).Value);\r
+ Assert ("#N08", !(Test3 > Test2).Value);\r
+ Assert ("#N09", (Test1 > SqlDateTime.Null).IsNull);\r
+\r
+ // >= -operator\r
+ Assert ("#N10", !(Test1 >= Test3).Value);\r
+ Assert ("#N11", (Test3 >= Test1).Value);\r
+ Assert ("#N12", (Test2 >= Test3).Value);\r
+ Assert ("#N13", (Test1 >= SqlDateTime.Null).IsNull);\r
+\r
+ // < -operator\r
+ Assert ("#N14", !(Test2 < Test1).Value);\r
+ Assert ("#N15", (Test1 < Test3).Value);\r
+ Assert ("#N16", !(Test2 < Test3).Value);\r
+ Assert ("#N17", (Test1 < SqlDateTime.Null).IsNull);\r
+\r
+ // <= -operator\r
+ Assert ("#N18", (Test1 <= Test3).Value);\r
+ Assert ("#N19", !(Test3 <= Test1).Value);\r
+ Assert ("#N20", (Test2 <= Test3).Value);\r
+ Assert ("#N21", (Test1 <= SqlDateTime.Null).IsNull);\r
+ }\r
+\r
+ public void TestSqlDateTimeToDateTime()\r
+ {\r
+ AssertEquals ("O01", 2002, ((DateTime)Test1).Year);\r
+ AssertEquals ("O03", 2003, ((DateTime)Test2).Year);\r
+ AssertEquals ("O04", 10, ((DateTime)Test1).Month);\r
+ AssertEquals ("O05", 19, ((DateTime)Test1).Day);\r
+ AssertEquals ("O06", 9, ((DateTime)Test1).Hour);\r
+ AssertEquals ("O07", 40, ((DateTime)Test1).Minute);\r
+ AssertEquals ("O08", 0, ((DateTime)Test1).Second);\r
+ }\r
+\r
+ public void TestSqlStringToSqlDateTime()\r
+ {\r
+\r
+ SqlString TestString = new SqlString ("02/25/2002");\r
+ SqlDateTime t1 = (SqlDateTime)TestString;\r
+\r
+ AssertEquals ("#P01", myTicks[0], t1.Value.Ticks);\r
+\r
+ // Thanks for Martin Baulig for these (DateTimeTest.cs)\r
+ AssertEquals ("#P02", myTicks[0], t1.Value.Ticks);\r
+ t1 = (SqlDateTime) new SqlString ("Monday, 25 February 2002");\r
+ AssertEquals ("#P04", myTicks[0], t1.Value.Ticks);\r
+ t1 = (SqlDateTime) new SqlString ("Monday, 25 February 2002 05:25");\r
+ AssertEquals ("#P05", myTicks[3], t1.Value.Ticks);\r
+ t1 = (SqlDateTime) new SqlString ("Monday, 25 February 2002 05:25:13");\r
+ AssertEquals ("#P05", myTicks[4], t1.Value.Ticks);\r
+ t1 = (SqlDateTime) new SqlString ("02/25/2002 05:25");\r
+ AssertEquals ("#P06", myTicks[3], t1.Value.Ticks);\r
+ t1 = (SqlDateTime) new SqlString ("02/25/2002 05:25:13");\r
+ AssertEquals ("#P07", myTicks[4], t1.Value.Ticks);\r
+ t1 = (SqlDateTime) new SqlString ("2002-02-25 04:25:13Z");\r
+ t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1.Value);\r
+ AssertEquals ("#P08", 2002, t1.Value.Year);\r
+ AssertEquals ("#P09", 02, t1.Value.Month);\r
+ AssertEquals ("#P10", 25, t1.Value.Day);\r
+ AssertEquals ("#P11", 04, t1.Value.Hour);\r
+ AssertEquals ("#P12", 25, t1.Value.Minute);\r
+ AssertEquals ("#P13", 13, t1.Value.Second);\r
+ \r
+ SqlDateTime t2 = new SqlDateTime (DateTime.Today.Year, 2, 25);\r
+ t1 = (SqlDateTime) new SqlString ("February 25");\r
+ AssertEquals ("#P14", t2.Value.Ticks, t1.Value.Ticks);\r
+ \r
+ t2 = new SqlDateTime (DateTime.Today.Year, 2, 8);\r
+ t1 = (SqlDateTime) new SqlString ("February 08");\r
+ AssertEquals ("#P15", t2.Value.Ticks, t1.Value.Ticks);\r
+\r
+ t1 = (SqlDateTime) new SqlString ("Mon, 25 Feb 2002 04:25:13 GMT");\r
+ t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1.Value);\r
+ AssertEquals ("#P16", 2002, t1.Value.Year);\r
+ AssertEquals ("#P17", 02, t1.Value.Month);\r
+ AssertEquals ("#P18", 25, t1.Value.Day);\r
+ AssertEquals ("#P19", 04, t1.Value.Hour);\r
+ AssertEquals ("#P20", 25, t1.Value.Minute);\r
+ AssertEquals ("#P21", 13, t1.Value.Second);\r
+\r
+ t1 = (SqlDateTime) new SqlString ("2002-02-25T05:25:13");\r
+ AssertEquals ("#P22", myTicks[4], t1.Value.Ticks);\r
+\r
+ t2 = DateTime.Today + new TimeSpan (5,25,0);\r
+ t1 = (SqlDateTime) new SqlString ("05:25");\r
+ AssertEquals("#P23", t2.Value.Ticks, t1.Value.Ticks);\r
+\r
+ t2 = DateTime.Today + new TimeSpan (5,25,13);\r
+ t1 = (SqlDateTime) new SqlString ("05:25:13");\r
+ AssertEquals("#P24", t2.Value.Ticks, t1.Value.Ticks);\r
+\r
+ t2 = new SqlDateTime (2002, 2, 1);\r
+ t1 = (SqlDateTime) new SqlString ("2002 February");\r
+ AssertEquals ("#P25", t2.Value.Ticks, t1.Value.Ticks);\r
+ \r
+ t2 = new SqlDateTime (2002, 2, 1);\r
+ t1 = (SqlDateTime) new SqlString ("2002 February");\r
+ AssertEquals ("#P26", t2.Value.Ticks, t1.Value.Ticks);\r
+ \r
+ t2 = new SqlDateTime (DateTime.Today.Year, 2, 8);\r
+ t1 = (SqlDateTime) new SqlString ("February 8");\r
+ \r
+ AssertEquals ("#P27", t2.Value.Ticks, t1.Value.Ticks);\r
+ }\r
+\r
+ public void TestDateTimeToSqlDateTime()\r
+ {\r
+ DateTime DateTimeTest = new DateTime (2002, 10, 19, 11, 53, 4);\r
+ SqlDateTime Result = (SqlDateTime)DateTimeTest;\r
+ AssertEquals ("#Q01", 2002, Result.Value.Year);\r
+ AssertEquals ("#Q02", 10, Result.Value.Month);\r
+ AssertEquals ("#Q03", 19, Result.Value.Day);\r
+ AssertEquals ("#Q04", 11, Result.Value.Hour);\r
+ AssertEquals ("#Q05", 53, Result.Value.Minute);\r
+ AssertEquals ("#Q06", 4, Result.Value.Second);\r
+ }\r
+ }\r
+}\r
+\r
--- /dev/null
+//\r
+// SqlMoneyTest.cs - NUnit Test Cases for System.Data.SqlTypes.SqlMoney\r
+//\r
+// Ville Palo (vi64pa@koti.soon.fi)\r
+//\r
+// (C) Ville Palo 2002\r
+// \r
+\r
+using NUnit.Framework;\r
+using System;\r
+using System.Data.SqlTypes;\r
+\r
+namespace MonoTests.System.Data.SqlTypes\r
+{\r
+ public class SqlMoneyTest : TestCase {\r
+\r
+ private SqlMoney Test1;\r
+ private SqlMoney Test2;\r
+ private SqlMoney Test3;\r
+ private SqlMoney Test4;\r
+\r
+ public SqlMoneyTest() : base ("System.Data.SqlTypes.SqlMoney") {}\r
+ public SqlMoneyTest(string name) : base(name) {}\r
+\r
+ protected override void TearDown() {}\r
+\r
+ protected override void SetUp() \r
+ {\r
+ Test1 = new SqlMoney (6464.6464d);\r
+ Test2 = new SqlMoney (90000.0m);\r
+ Test3 = new SqlMoney (90000.0m);\r
+ Test4 = new SqlMoney (-45000.0m);\r
+ }\r
+\r
+ public static ITest Suite {\r
+ get {\r
+ return new TestSuite(typeof(SqlMoney));\r
+ }\r
+ }\r
+\r
+ // Test constructor\r
+ public void TestCreate()\r
+ {\r
+ try {\r
+ SqlMoney Test = new SqlMoney (1000000000000000m);\r
+ Fail ("#B01");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#A02", typeof (OverflowException),\r
+ e.GetType ());\r
+ }\r
+\r
+ SqlMoney CreationTest = new SqlMoney ((decimal)913.3);\r
+ AssertEquals ("A03", 913.3m, CreationTest.Value);\r
+\r
+ try {\r
+ SqlMoney Test = new SqlMoney (1e200);\r
+ Fail ("#B04");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#A05", typeof (OverflowException),\r
+ e.GetType ());\r
+ }\r
+ \r
+ SqlMoney CreationTest2 = new SqlMoney ((double)913.3);\r
+ AssertEquals ("A06", 913.3m, CreationTest2.Value);\r
+\r
+ SqlMoney CreationTest3 = new SqlMoney ((int)913);\r
+ AssertEquals ("A07", 913m, CreationTest3.Value);\r
+\r
+ SqlMoney CreationTest4 = new SqlMoney ((long)913.3);\r
+ AssertEquals ("A08", 913m, CreationTest4.Value);\r
+ }\r
+\r
+ // Test public fields\r
+ public void TestPublicFields()\r
+ {\r
+ // FIXME: There is a error in msdn docs, it says thath MaxValue\r
+ // is 922,337,203,685,475.5807 when the actual value is\r
+ // 922,337,203,685,477.5807\r
+ AssertEquals ("#B01", 922337203685477.5807m, SqlMoney.MaxValue.Value);\r
+ AssertEquals ("#B02", -922337203685477.5808m, SqlMoney.MinValue.Value);\r
+ Assert ("#B03", SqlMoney.Null.IsNull);\r
+ AssertEquals ("#B04", 0m, SqlMoney.Zero.Value);\r
+ }\r
+\r
+ // Test properties\r
+ public void TestProperties()\r
+ {\r
+ AssertEquals ("#C01", 90000m, Test2.Value);\r
+ AssertEquals ("#C02", -45000m, Test4.Value);\r
+ Assert ("#C03", SqlMoney.Null.IsNull);\r
+ }\r
+\r
+ // PUBLIC METHODS\r
+\r
+ public void TestArithmeticMethods()\r
+ {\r
+ SqlMoney TestMoney2 = new SqlMoney (2);\r
+\r
+ // Add\r
+ AssertEquals ("#D01", (SqlMoney)96464.6464, SqlMoney.Add (Test1, Test2));\r
+ AssertEquals ("#D02", (SqlMoney)180000, SqlMoney.Add (Test2, Test2));\r
+ AssertEquals ("#D03", (SqlMoney)45000, SqlMoney.Add (Test2, Test4));\r
+ \r
+ try {\r
+ SqlMoney test = SqlMoney.Add(SqlMoney.MaxValue, Test2);\r
+ Fail ("#D04");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#D05", typeof (OverflowException), e.GetType ());\r
+ }\r
+\r
+ // Divide\r
+ AssertEquals ("#D06", (SqlMoney)45000, SqlMoney.Divide (Test2, TestMoney2));\r
+ try {\r
+ SqlMoney test = SqlMoney.Divide (Test2, SqlMoney.Zero);\r
+ Fail ("#D07");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#D08", typeof (DivideByZeroException), \r
+ e.GetType());\r
+ }\r
+ \r
+ // Multiply\r
+ AssertEquals ("#D09", (SqlMoney)581818176, SqlMoney.Multiply (Test1, Test2));\r
+ AssertEquals ("#D10", (SqlMoney)(-4050000000), SqlMoney.Multiply (Test3, Test4));\r
+\r
+ try {\r
+ SqlMoney test = SqlMoney.Multiply (SqlMoney.MaxValue, Test2);\r
+ Fail ("#D11");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#D12", typeof (OverflowException), e.GetType ());\r
+ }\r
+ \r
+ // Subtract\r
+ AssertEquals ("#D13", (SqlMoney)0, SqlMoney.Subtract (Test2, Test3));\r
+ AssertEquals ("#D14", (SqlMoney)83535.3536, SqlMoney.Subtract (Test2, Test1));\r
+ \r
+ try {\r
+ SqlMoney test = SqlMoney.Subtract (SqlMoney.MinValue, Test2);\r
+ } catch (Exception e) {\r
+ AssertEquals ("#D15", typeof (OverflowException), e.GetType ());\r
+ }\r
+ }\r
+\r
+ public void TestCompareTo()\r
+ {\r
+ Assert ("#E01", Test1.CompareTo (Test2) < 0);\r
+ Assert ("#E02", Test3.CompareTo (Test1) > 0);\r
+ Assert ("#E03", Test3.CompareTo (Test2) == 0);\r
+ Assert ("#E04", Test3.CompareTo (SqlMoney.Null) > 0);\r
+ }\r
+\r
+ public void TestEqualsMethods()\r
+ {\r
+ Assert ("#F01", !Test1.Equals (Test2));\r
+ Assert ("#F02", Test2.Equals (Test3));\r
+ Assert ("#F03", !SqlMoney.Equals (Test1, Test2).Value);\r
+ Assert ("#F04", SqlMoney.Equals (Test3, Test2).Value);\r
+ }\r
+\r
+ public void TestGetHashCode()\r
+ {\r
+ // FIXME: Better way to test HashCode\r
+ AssertEquals ("#G01", Test3.GetHashCode (), Test2.GetHashCode ());\r
+ Assert ("#G02", Test2.GetHashCode () != Test1.GetHashCode ());\r
+ }\r
+\r
+ public void TestGetType()\r
+ {\r
+ AssertEquals ("#H01", "System.Data.SqlTypes.SqlMoney", \r
+ Test1.GetType ().ToString ());\r
+ }\r
+\r
+ public void TestGreaters()\r
+ {\r
+ // GreateThan ()\r
+ Assert ("#I01", !SqlMoney.GreaterThan (Test1, Test2).Value);\r
+ Assert ("#I02", SqlMoney.GreaterThan (Test2, Test1).Value);\r
+ Assert ("#I03", !SqlMoney.GreaterThan (Test2, Test3).Value);\r
+ Assert ("#I04", SqlMoney.GreaterThan (Test2, SqlMoney.Null).IsNull);\r
+\r
+ // GreaterTharOrEqual ()\r
+ Assert ("#I05", !SqlMoney.GreaterThanOrEqual (Test1, Test2).Value);\r
+ Assert ("#I06", SqlMoney.GreaterThanOrEqual (Test2, Test1).Value);\r
+ Assert ("#I07", SqlMoney.GreaterThanOrEqual (Test3, Test2).Value);\r
+ Assert ("#I08", SqlMoney.GreaterThanOrEqual (Test3, SqlMoney.Null).IsNull);\r
+ }\r
+\r
+ public void TestLessers()\r
+ {\r
+ // LessThan()\r
+ Assert ("#J01", !SqlMoney.LessThan (Test2, Test3).Value);\r
+ Assert ("#J02", !SqlMoney.LessThan (Test2, Test1).Value);\r
+ Assert ("#J03", SqlMoney.LessThan (Test1, Test2).Value);\r
+ Assert ("#J04", SqlMoney.LessThan (SqlMoney.Null, Test2).IsNull);\r
+\r
+ // LessThanOrEqual ()\r
+ Assert ("#J05", SqlMoney.LessThanOrEqual (Test1, Test2).Value);\r
+ Assert ("#J06", !SqlMoney.LessThanOrEqual (Test2, Test1).Value);\r
+ Assert ("#J07", SqlMoney.LessThanOrEqual (Test2, Test2).Value);\r
+ Assert ("#J08", SqlMoney.LessThanOrEqual (Test2, SqlMoney.Null).IsNull);\r
+ }\r
+\r
+ public void TestNotEquals()\r
+ {\r
+ Assert ("#K01", SqlMoney.NotEquals (Test1, Test2).Value);\r
+ Assert ("#K02", SqlMoney.NotEquals (Test2, Test1).Value);\r
+ Assert ("#K03", !SqlMoney.NotEquals (Test2, Test3).Value);\r
+ Assert ("#K04", !SqlMoney.NotEquals (Test3, Test2).Value);\r
+ Assert ("#K05", SqlMoney.NotEquals (SqlMoney.Null, Test2).IsNull);\r
+ }\r
+\r
+ public void TestParse()\r
+ {\r
+ try {\r
+ SqlMoney.Parse (null);\r
+ Fail ("#L01");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#L02", typeof (ArgumentNullException), e.GetType ());\r
+ }\r
+\r
+ try {\r
+ SqlMoney.Parse ("not-a-number");\r
+ Fail ("#L03");\r
+ } catch (Exception e) {\r
+\r
+ AssertEquals ("#L04", typeof (FormatException), e.GetType ());\r
+ }\r
+\r
+ try {\r
+ SqlMoney.Parse ("1000000000000000");\r
+ Fail ("#L05");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#L06", typeof (OverflowException), e.GetType ());\r
+ }\r
+\r
+ AssertEquals("#L07", (decimal)150, SqlMoney.Parse ("150").Value);\r
+ }\r
+\r
+ public void TestConversions()\r
+ { \r
+ SqlMoney TestMoney100 = new SqlMoney (100);\r
+\r
+ // ToDecimal\r
+ AssertEquals ("#M01", (decimal)6464.6464, Test1.ToDecimal ());\r
+\r
+ // ToDouble\r
+ AssertEquals ("#M02", (double)6464.6464, Test1.ToDouble ());\r
+\r
+ // ToInt32\r
+ AssertEquals ("#M03", (int)90000, Test2.ToInt32 ());\r
+ AssertEquals ("#M04", (int)6465, Test1.ToInt32 ());\r
+\r
+ // ToInt64\r
+ AssertEquals ("#M05", (long)90000, Test2.ToInt64 ());\r
+ AssertEquals ("#M06", (long)6465, Test1.ToInt64 ());\r
+\r
+ // ToSqlBoolean ()\r
+ Assert ("#M07", Test1.ToSqlBoolean ().Value);\r
+ Assert ("#M08", !SqlMoney.Zero.ToSqlBoolean ().Value);\r
+ Assert ("#M09", SqlMoney.Null.ToSqlBoolean ().IsNull);\r
+\r
+ // ToSqlByte ()\r
+ AssertEquals ("#M10", (byte)100, TestMoney100.ToSqlByte ().Value);\r
+\r
+ try {\r
+ SqlByte b = (byte)Test2.ToSqlByte ();\r
+ Fail ("#M11");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#M12", typeof (OverflowException), e.GetType ());\r
+ }\r
+\r
+ // ToSqlDecimal ()\r
+ AssertEquals ("#M13", (decimal)6464.6464, Test1.ToSqlDecimal ().Value);\r
+ AssertEquals ("#M14", (decimal)-45000, Test4.ToSqlDecimal ().Value);\r
+\r
+ // ToSqlInt16 ()\r
+ AssertEquals ("#M15", (short)6465, Test1.ToSqlInt16 ().Value);\r
+\r
+ try {\r
+ SqlInt16 test = SqlMoney.MaxValue.ToSqlInt16().Value;\r
+ Fail ("#M17");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#M18", typeof (OverflowException), e.GetType ());\r
+ } \r
+\r
+ // ToSqlInt32 ()\r
+ AssertEquals ("#M19", (int)6465, Test1.ToSqlInt32 ().Value);\r
+ AssertEquals ("#M20", (int)(-45000), Test4.ToSqlInt32 ().Value);\r
+\r
+ try {\r
+ SqlInt32 test = SqlMoney.MaxValue.ToSqlInt32 ().Value;\r
+ Fail ("#M21");\r
+ } catch (Exception e) { \r
+ AssertEquals ("#M22", typeof (OverflowException), e.GetType ());\r
+ }\r
+\r
+ // ToSqlInt64 ()\r
+ AssertEquals ("#M23", (long)6465, Test1.ToSqlInt64 ().Value);\r
+ AssertEquals ("#M24", (long)(-45000), Test4.ToSqlInt64 ().Value);\r
+\r
+ // ToSqlSingle ()\r
+ AssertEquals ("#M25", (float)6464.6464, Test1.ToSqlSingle ().Value);\r
+\r
+ // ToSqlString ()\r
+ AssertEquals ("#M26", "6464,6464", Test1.ToSqlString ().Value);\r
+ AssertEquals ("#M27", "90000", Test2.ToSqlString ().Value);\r
+\r
+ // ToString ()\r
+ AssertEquals ("#M28", "6464,6464", Test1.ToString ());\r
+ AssertEquals ("#M29", "90000", Test2.ToString ());\r
+ }\r
+\r
+ // OPERATORS\r
+\r
+ public void TestArithmeticOperators()\r
+ {\r
+ // "+"-operator\r
+ AssertEquals ("#N01", (SqlMoney)96464.6464, Test1 + Test2);\r
+ \r
+ try {\r
+ SqlMoney test = SqlMoney.MaxValue + SqlMoney.MaxValue;\r
+ Fail ("#N02");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#N03", typeof (OverflowException), e.GetType ());\r
+ }\r
+\r
+ // "/"-operator\r
+ AssertEquals ("#N04", (SqlMoney)13.9219, Test2 / Test1);\r
+\r
+ try {\r
+ SqlMoney test = Test3 / SqlMoney.Zero;\r
+ Fail ("#N05");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#N06", typeof (DivideByZeroException), e.GetType ());\r
+ }\r
+\r
+ // "*"-operator\r
+ AssertEquals ("#N07", (SqlMoney)581818176, Test1 * Test2);\r
+\r
+ try {\r
+ SqlMoney test = SqlMoney.MaxValue * Test1;\r
+ Fail ("#N08");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#N09", typeof (OverflowException), e.GetType ());\r
+ }\r
+\r
+ // "-"-operator\r
+ AssertEquals ("#N10", (SqlMoney)83535.3536, Test2 - Test1);\r
+\r
+ try {\r
+ SqlMoney test = SqlMoney.MinValue - SqlMoney.MaxValue;\r
+ Fail ("#N11");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#N12", typeof (OverflowException), e.GetType ());\r
+ }\r
+ }\r
+\r
+ public void TestThanOrEqualOperators()\r
+ {\r
+ // == -operator\r
+ Assert ("#O01", (Test2 == Test2).Value);\r
+ Assert ("#O02", !(Test1 == Test2).Value);\r
+ Assert ("#O03", (Test1 == SqlMoney.Null).IsNull);\r
+ \r
+ // != -operator\r
+ Assert ("#O04", !(Test2 != Test3).Value);\r
+ Assert ("#O05", (Test1 != Test3).Value);\r
+ Assert ("#O06", (Test1 != Test4).Value);\r
+ Assert ("#O07", (Test1 != SqlMoney.Null).IsNull);\r
+\r
+ // > -operator\r
+ Assert ("#O08", (Test1 > Test4).Value);\r
+ Assert ("#O09", (Test2 > Test1).Value);\r
+ Assert ("#O10", !(Test2 > Test3).Value);\r
+ Assert ("#O11", (Test1 > SqlMoney.Null).IsNull);\r
+\r
+ // >= -operator\r
+ Assert ("#O12", !(Test1 >= Test3).Value);\r
+ Assert ("#O13", (Test3 >= Test1).Value);\r
+ Assert ("#O14", (Test2 >= Test3).Value);\r
+ Assert ("#O15", (Test1 >= SqlMoney.Null).IsNull);\r
+\r
+ // < -operator\r
+ Assert ("#O16", !(Test2 < Test1).Value);\r
+ Assert ("#O17", (Test1 < Test3).Value);\r
+ Assert ("#O18", !(Test2 < Test3).Value);\r
+ Assert ("#O19", (Test1 < SqlMoney.Null).IsNull);\r
+\r
+ // <= -operator\r
+ Assert ("#O20", (Test1 <= Test3).Value);\r
+ Assert ("#O21", !(Test3 <= Test1).Value);\r
+ Assert ("#O22", (Test2 <= Test3).Value);\r
+ Assert ("#O23", (Test1 <= SqlMoney.Null).IsNull);\r
+ }\r
+\r
+ public void TestUnaryNegation()\r
+ {\r
+\r
+ AssertEquals ("#P01", (decimal)(-6464.6464), -(Test1).Value);\r
+ AssertEquals ("#P02", (decimal)45000, -(Test4).Value);\r
+ }\r
+\r
+ public void TestSqlBooleanToSqlMoney()\r
+ {\r
+ SqlBoolean TestBoolean = new SqlBoolean (true);\r
+\r
+ AssertEquals ("#Q01", (decimal)1, ((SqlMoney)TestBoolean).Value);\r
+ Assert ("#Q02", ((SqlDecimal)SqlBoolean.Null).IsNull);\r
+ }\r
+ \r
+ public void TestSqlDecimalToSqlMoney()\r
+ {\r
+ SqlDecimal TestDecimal = new SqlDecimal (4000);\r
+ SqlDecimal TestDecimal2 = new SqlDecimal (1e20);\r
+\r
+ SqlMoney TestMoney = (SqlMoney)TestDecimal;\r
+ AssertEquals ("#R01", TestMoney.Value, TestDecimal.Value);\r
+\r
+ try {\r
+ SqlMoney test = (SqlMoney)TestDecimal2;\r
+ Fail ("#R02");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#R03", typeof (OverflowException), e.GetType ());\r
+ }\r
+ }\r
+ \r
+ public void TestSqlDoubleToSqlMoney()\r
+ {\r
+ SqlDouble TestDouble = new SqlDouble (1e9);\r
+ SqlDouble TestDouble2 = new SqlDouble (1e20);\r
+ \r
+ SqlMoney TestMoney = (SqlMoney)TestDouble;\r
+ AssertEquals ("#S01", 1000000000m, TestMoney.Value);\r
+\r
+ try {\r
+ SqlMoney test = (SqlMoney)TestDouble2;\r
+ Fail ("#S02");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#S03", typeof (OverflowException), e.GetType ());\r
+ }\r
+ }\r
+\r
+ public void SqlMoneyToDecimal()\r
+ {\r
+ AssertEquals ("#T01", (decimal)6464.6464, (decimal)Test1);\r
+ AssertEquals ("#T02", (decimal)(-45000), (decimal)Test4);\r
+ }\r
+\r
+ public void SqlSingleToSqlMoney()\r
+ {\r
+ SqlSingle TestSingle = new SqlSingle (1e10);\r
+ SqlSingle TestSingle2 = new SqlSingle (1e20);\r
+\r
+ AssertEquals ("#U01", 10000000000m, ((SqlMoney)TestSingle).Value);\r
+\r
+ try {\r
+ SqlMoney test = (SqlMoney)TestSingle2;\r
+ Fail ("#U02");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#U03", typeof (OverflowException), e.GetType());\r
+ }\r
+ }\r
+\r
+ public void TestSqlStringToSqlMoney()\r
+ {\r
+ SqlString TestString = new SqlString ("Test string");\r
+ SqlString TestString100 = new SqlString ("100");\r
+\r
+ AssertEquals ("#V01", (decimal)100, ((SqlMoney)TestString100).Value);\r
+\r
+ try {\r
+ SqlMoney test = (SqlMoney)TestString;\r
+ Fail ("#V02");\r
+ } catch(Exception e) {\r
+ AssertEquals ("#V03", typeof (FormatException), e.GetType ());\r
+ }\r
+ }\r
+\r
+ public void DecimalToSqlMoney()\r
+ {\r
+ decimal TestDecimal = 1e10m;\r
+ decimal TestDecimal2 = 1e20m;\r
+ AssertEquals ("#W01", 10000000000, ((SqlMoney)TestDecimal).Value);\r
+ \r
+ try {\r
+ SqlMoney test = (SqlMoney)TestDecimal2;\r
+ Fail ("#W02");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#W03", typeof (OverflowException), e.GetType ());\r
+ } \r
+ }\r
+\r
+ public void SqlByteToSqlMoney() \r
+ {\r
+ SqlByte TestByte = new SqlByte ((byte)200); \r
+ AssertEquals ("#X01", 200m, ((SqlMoney)TestByte).Value);\r
+ }\r
+\r
+ public void IntsToSqlMoney()\r
+ {\r
+ SqlInt16 TestInt16 = new SqlInt16 (5000);\r
+ SqlInt32 TestInt32 = new SqlInt32 (5000);\r
+ SqlInt64 TestInt64 = new SqlInt64 (5000);\r
+ \r
+ AssertEquals ("#Y01", 5000m, ((SqlMoney)TestInt16).Value);\r
+ AssertEquals ("#Y02", 5000m, ((SqlMoney)TestInt32).Value);\r
+ AssertEquals ("#Y03", 5000m, ((SqlMoney)TestInt64).Value);\r
+\r
+ try {\r
+ SqlMoney test = (SqlMoney)SqlInt64.MaxValue;\r
+ Fail ("#Y04");\r
+ } catch (Exception e) {\r
+ AssertEquals ("#Y05", typeof (OverflowException), e.GetType ());\r
+ }\r
+ }\r
+ }\r
+}\r
+\r
projects / mono.git / commitdiff