mcs/class/System.Data/Test/System.Data.SqlTypes/SqlDateTimeTest.cs

   1 //\r
   2 // SqlDateTimeTest.cs - NUnit Test Cases for System.Data.SqlTypes.SqlDateTime\r
   3 //\r
   4 // Authors:\r
   5 //   Ville Palo (vi64pa@koti.soon.fi)\r
   6 //   Martin Willemoes Hansen\r
   7 //\r
   8 // (C) 2002 Ville Palo\r
   9 // (C) 2003 Martin Willemoes Hansen\r
  10 // \r
  11
  12 //
  13 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  14 //
  15 // Permission is hereby granted, free of charge, to any person obtaining
  16 // a copy of this software and associated documentation files (the
  17 // "Software"), to deal in the Software without restriction, including
  18 // without limitation the rights to use, copy, modify, merge, publish,
  19 // distribute, sublicense, and/or sell copies of the Software, and to
  20 // permit persons to whom the Software is furnished to do so, subject to
  21 // the following conditions:
  22 //
  23 // The above copyright notice and this permission notice shall be
  24 // included in all copies or substantial portions of the Software.
  25 //
  26 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  27 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  28 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  29 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  30 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  31 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  32 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  33 //
  34 \r
  35 using NUnit.Framework;\r
  36 using System;\r
  37 using System.Data.SqlTypes;\r
  38 using System.Threading;\r
  39 using System.Globalization;\r
  40 \r
  41 namespace MonoTests.System.Data.SqlTypes\r
  42 {\r
  43         [TestFixture]\r
  44         public class SqlDateTimeTest : Assertion {\r
  45 \r
  46                 private long[] myTicks = {\r
  47                         631501920000000000L,    // 25 Feb 2002 - 00:00:00\r
  48                         631502475130080000L,    // 25 Feb 2002 - 15:25:13,8\r
  49                         631502115130080000L,    // 25 Feb 2002 - 05:25:13,8\r
  50                         631502115000000000L,    // 25 Feb 2002 - 05:25:00\r
  51                         631502115130000000L,    // 25 Feb 2002 - 05:25:13\r
  52                         631502079130000000L,    // 25 Feb 2002 - 04:25:13\r
  53                         629197085770000000L     // 06 Nov 1994 - 08:49:37 \r
  54                 };\r
  55 \r
  56                 private SqlDateTime Test1;\r
  57                 private SqlDateTime Test2;\r
  58                 private SqlDateTime Test3;\r
  59 \r
  60                 [SetUp]\r
  61                 public void GetReady() \r
  62                 {\r
  63                         Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");\r
  64                         Test1 = new SqlDateTime (2002, 10, 19, 9, 40, 0);\r
  65                         Test2 = new SqlDateTime (2003, 11, 20,10, 50, 1);\r
  66                         Test3 = new SqlDateTime (2003, 11, 20, 10, 50, 1);\r
  67                 }\r
  68 \r
  69                 // Test constructor\r
  70                 [Test]\r
  71                 public void Create()\r
  72                 {\r
  73                         // SqlDateTime (DateTime)\r
  74                         SqlDateTime CTest = new SqlDateTime (\r
  75                                 new DateTime (2002, 5, 19, 3, 34, 0));\r
  76                         AssertEquals ("#A01", 2002, CTest.Value.Year);\r
  77                                 \r
  78                         // SqlDateTime (int, int)\r
  79                         CTest = new SqlDateTime (0, 0);\r
  80                         \r
  81                         // SqlDateTime (int, int, int)\r
  82                         AssertEquals ("#A02", 1900, CTest.Value.Year);\r
  83                         AssertEquals ("#A03", 1, CTest.Value.Month);\r
  84                         AssertEquals ("#A04", 1, CTest.Value.Day);\r
  85                         AssertEquals ("#A05", 0, CTest.Value.Hour);\r
  86 \r
  87                         // SqlDateTime (int, int, int, int, int, int)\r
  88                         CTest = new SqlDateTime (5000, 12, 31);\r
  89                         AssertEquals ("#A06", 5000, CTest.Value.Year);\r
  90                         AssertEquals ("#A07", 12, CTest.Value.Month);\r
  91                         AssertEquals ("#A08", 31, CTest.Value.Day);\r
  92 \r
  93                         // SqlDateTime (int, int, int, int, int, int, double)\r
  94                         CTest = new SqlDateTime (1978, 5, 19, 3, 34, 0);\r
  95                         AssertEquals ("#A09", 1978, CTest.Value.Year);\r
  96                         AssertEquals ("#A10", 5, CTest.Value.Month);\r
  97                         AssertEquals ("#A11", 19, CTest.Value.Day);\r
  98                         AssertEquals ("#A12", 3, CTest.Value.Hour);\r
  99                         AssertEquals ("#A13", 34, CTest.Value.Minute);\r
 100                         AssertEquals ("#A14", 0, CTest.Value.Second);\r
 101                         \r
 102                         try {\r
 103                                 CTest = new SqlDateTime (10000, 12, 31);\r
 104                                 Fail ("#A15");\r
 105                         } catch (Exception e) {\r
 106                                 AssertEquals ("#A16", typeof (SqlTypeException),\r
 107                                               e.GetType ());\r
 108                         }\r
 109                         \r
 110                         // SqlDateTime (int, int, int, int, int, int, int)\r
 111                         CTest = new SqlDateTime (1978, 5, 19, 3, 34, 0, 12);\r
 112                         AssertEquals ("#A17", 1978, CTest.Value.Year);\r
 113                         AssertEquals ("#A18", 5, CTest.Value.Month);\r
 114                         AssertEquals ("#A19", 19, CTest.Value.Day);\r
 115                         AssertEquals ("#A20", 3, CTest.Value.Hour);\r
 116                         AssertEquals ("#A21", 34, CTest.Value.Minute);\r
 117                         AssertEquals ("#A22", 0, CTest.Value.Second);\r
 118                         AssertEquals ("#A23", 0, CTest.Value.Millisecond);\r
 119                 }\r
 120 \r
 121                 // Test public fields\r
 122                 [Test]\r
 123                 public void PublicFields()\r
 124                 {\r
 125                         // MaxValue\r
 126                         AssertEquals ("#B01", 9999, SqlDateTime.MaxValue.Value.Year);\r
 127                         AssertEquals ("#B02", 12, SqlDateTime.MaxValue.Value.Month);\r
 128                         AssertEquals ("#B03", 31, SqlDateTime.MaxValue.Value.Day);\r
 129                         AssertEquals ("#B04", 23, SqlDateTime.MaxValue.Value.Hour);\r
 130                         AssertEquals ("#B05", 59, SqlDateTime.MaxValue.Value.Minute);\r
 131                         AssertEquals ("#B06", 59, SqlDateTime.MaxValue.Value.Second);\r
 132 \r
 133                         // MinValue\r
 134                         AssertEquals ("#B07", 1753, SqlDateTime.MinValue.Value.Year);\r
 135                         AssertEquals ("#B08", 1, SqlDateTime.MinValue.Value.Month);\r
 136                         AssertEquals ("#B09", 1, SqlDateTime.MinValue.Value.Day);\r
 137                         AssertEquals ("#B10", 0, SqlDateTime.MinValue.Value.Hour);\r
 138                         AssertEquals ("#B11", 0, SqlDateTime.MinValue.Value.Minute);\r
 139                         AssertEquals ("#B12", 0, SqlDateTime.MinValue.Value.Second);\r
 140 \r
 141                         // Null\r
 142                         Assert ("#B13", SqlDateTime.Null.IsNull);\r
 143 \r
 144                         // SQLTicksPerHour\r
 145                         AssertEquals ("#B14", 1080000, SqlDateTime.SQLTicksPerHour);\r
 146 \r
 147                         // SQLTicksPerMinute\r
 148                         AssertEquals ("#B15", 18000, SqlDateTime.SQLTicksPerMinute);\r
 149 \r
 150                         // SQLTicksPerSecond\r
 151                         AssertEquals ("#B16", 300, SqlDateTime.SQLTicksPerSecond);\r
 152                 }\r
 153 \r
 154                 // Test properties\r
 155                 [Test]\r
 156                 public void Properties()\r
 157                 {\r
 158                         // DayTicks\r
 159                         AssertEquals ("#C01", 37546, Test1.DayTicks);\r
 160                         \r
 161                         try {\r
 162                                 int test = SqlDateTime.Null.DayTicks;\r
 163                                 Fail ("#C02");\r
 164                         } catch (Exception e) {\r
 165                                 AssertEquals ("#C03", typeof (SqlNullValueException), \r
 166                                               e.GetType ());\r
 167                         }\r
 168                                 \r
 169                         // IsNull\r
 170                         Assert ("#C04", SqlDateTime.Null.IsNull);\r
 171                         Assert ("#C05", !Test2.IsNull);\r
 172 \r
 173                         // TimeTicks\r
 174                         AssertEquals ("#C06", 10440000, Test1.TimeTicks);\r
 175                         \r
 176                         try {\r
 177                                 int test = SqlDateTime.Null.TimeTicks;\r
 178                                 Fail ("#C07");\r
 179                         } catch (Exception e) {\r
 180                                 AssertEquals ("#C08", typeof (SqlNullValueException), \r
 181                                               e.GetType ());\r
 182                         }\r
 183 \r
 184                         // Value\r
 185                         AssertEquals ("#C09", 2003, Test2.Value.Year);\r
 186                         AssertEquals ("#C10", 2002, Test1.Value.Year);                  \r
 187                 }\r
 188 \r
 189                 // PUBLIC METHODS\r
 190 \r
 191                 [Test]          \r
 192                 public void CompareTo()\r
 193                 {\r
 194                         SqlString TestString = new SqlString ("This is a test");\r
 195 \r
 196                         Assert ("#D01", Test1.CompareTo (Test3) < 0);\r
 197                         Assert ("#D02", Test2.CompareTo (Test1) > 0);\r
 198                         Assert ("#D03", Test2.CompareTo (Test3) == 0);\r
 199                         Assert ("#D04", Test1.CompareTo (SqlDateTime.Null) > 0);\r
 200 \r
 201                         try {\r
 202                                 Test1.CompareTo (TestString);\r
 203                                 Fail("#D05");\r
 204                         } catch(Exception e) {\r
 205                                 AssertEquals ("#D06", typeof (ArgumentException), e.GetType ());\r
 206                         }\r
 207                 }\r
 208 \r
 209                 [Test]\r
 210                 public void EqualsMethods()\r
 211                 {\r
 212                         Assert ("#E01", !Test1.Equals (Test2));\r
 213                         Assert ("#E03", !Test2.Equals (new SqlString ("TEST")));\r
 214                         Assert ("#E04", Test2.Equals (Test3));\r
 215 \r
 216                         // Static Equals()-method\r
 217                         Assert ("#E05", SqlDateTime.Equals (Test2, Test3).Value);\r
 218                         Assert ("#E06", !SqlDateTime.Equals (Test1, Test2).Value);\r
 219                 }\r
 220 \r
 221                 [Test]\r
 222                 public void GetHashCodeTest()\r
 223                 {\r
 224                         // FIXME: Better way to test HashCode\r
 225                         AssertEquals ("#F01", Test1.GetHashCode (), Test1.GetHashCode ());\r
 226                         Assert ("#F02", Test2.GetHashCode () != Test1.GetHashCode ());\r
 227                 }\r
 228 \r
 229                 [Test]\r
 230                 public void GetTypeTest()\r
 231                 {\r
 232                         AssertEquals ("#G01", "System.Data.SqlTypes.SqlDateTime", \r
 233                                       Test1.GetType ().ToString ());\r
 234                         AssertEquals ("#G02", "System.DateTime", \r
 235                                       Test1.Value.GetType ().ToString ());\r
 236                 }\r
 237 \r
 238                 [Test]\r
 239                 public void Greaters()\r
 240                 {\r
 241                         // GreateThan ()\r
 242                         Assert ("#H01", !SqlDateTime.GreaterThan (Test1, Test2).Value);\r
 243                         Assert ("#H02", SqlDateTime.GreaterThan (Test2, Test1).Value);\r
 244                         Assert ("#H03", !SqlDateTime.GreaterThan (Test2, Test3).Value);\r
 245 \r
 246                         // GreaterTharOrEqual ()\r
 247                         Assert ("#H04", !SqlDateTime.GreaterThanOrEqual (Test1, Test2).Value);\r
 248                         Assert ("#H05", SqlDateTime.GreaterThanOrEqual (Test2, Test1).Value);\r
 249                         Assert ("#H06", SqlDateTime.GreaterThanOrEqual (Test2, Test3).Value);\r
 250                 }\r
 251 \r
 252                 [Test]\r
 253                 public void Lessers()\r
 254                 {\r
 255                         // LessThan()\r
 256                         Assert ("#I01", !SqlDateTime.LessThan (Test2, Test3).Value);\r
 257                         Assert ("#I02", !SqlDateTime.LessThan (Test2, Test1).Value);\r
 258                         Assert ("#I03", SqlDateTime.LessThan (Test1, Test3).Value);\r
 259 \r
 260                         // LessThanOrEqual ()\r
 261                         Assert ("#I04", SqlDateTime.LessThanOrEqual (Test1, Test2).Value);\r
 262                         Assert ("#I05", !SqlDateTime.LessThanOrEqual (Test2, Test1).Value);\r
 263                         Assert ("#I06", SqlDateTime.LessThanOrEqual (Test3, Test2).Value);\r
 264                         Assert ("#I07", SqlDateTime.LessThanOrEqual (Test1, SqlDateTime.Null).IsNull);\r
 265                 }\r
 266 \r
 267                 [Test]\r
 268                 public void NotEquals()\r
 269                 {\r
 270                         Assert ("#J01", SqlDateTime.NotEquals (Test1, Test2).Value);\r
 271                         Assert ("#J02", SqlDateTime.NotEquals (Test3, Test1).Value);\r
 272                         Assert ("#J03", !SqlDateTime.NotEquals (Test2, Test3).Value);\r
 273                         Assert ("#J04", SqlDateTime.NotEquals (SqlDateTime.Null, Test2).IsNull);\r
 274                 }\r
 275 \r
 276                 [Test]\r
 277                 public void Parse()\r
 278                 {\r
 279                         try {\r
 280                                 SqlDateTime.Parse (null);\r
 281                                 Fail ("#K01");\r
 282                         } catch (Exception e) {\r
 283                                 AssertEquals ("#K02", typeof (ArgumentNullException), \r
 284                                               e.GetType ());\r
 285                         }\r
 286 \r
 287                         try {\r
 288                                 SqlDateTime.Parse ("not-a-number");\r
 289                                 Fail ("#K03");\r
 290                         } catch (Exception e) {\r
 291                                 AssertEquals ("#K04", typeof (FormatException), \r
 292                                               e.GetType ());\r
 293                         }\r
 294 \r
 295                         SqlDateTime t1 = SqlDateTime.Parse ("02/25/2002");\r
 296                         AssertEquals ("#K05", myTicks[0], t1.Value.Ticks);\r
 297 \r
 298                         try {\r
 299                                 t1 = SqlDateTime.Parse ("2002-02-25");\r
 300                         } catch (Exception e) {\r
 301                                 Fail ("#K06 " + e);\r
 302                         }\r
 303 \r
 304                         // Thanks for Martin Baulig for these (DateTimeTest.cs)\r
 305                         AssertEquals ("#K07", myTicks[0], t1.Value.Ticks);\r
 306                         t1 = SqlDateTime.Parse ("Monday, 25 February 2002");\r
 307                         AssertEquals ("#K08", myTicks[0], t1.Value.Ticks);\r
 308                         t1 = SqlDateTime.Parse ("Monday, 25 February 2002 05:25");\r
 309                         AssertEquals ("#K09", myTicks[3], t1.Value.Ticks);\r
 310                         t1 = SqlDateTime.Parse ("Monday, 25 February 2002 05:25:13");\r
 311                         AssertEquals ("#K10", myTicks[4], t1.Value.Ticks);\r
 312                         t1 = SqlDateTime.Parse ("02/25/2002 05:25");\r
 313                         AssertEquals ("#K11", myTicks[3], t1.Value.Ticks);\r
 314                         t1 = SqlDateTime.Parse ("02/25/2002 05:25:13");\r
 315                         AssertEquals ("#K12", myTicks[4], t1.Value.Ticks);\r
 316                         t1 = SqlDateTime.Parse ("2002-02-25 04:25:13Z");\r
 317                         t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1.Value);\r
 318                         AssertEquals ("#K13", 2002, t1.Value.Year);\r
 319                         AssertEquals ("#K14", 02, t1.Value.Month);\r
 320                         AssertEquals ("#K15", 25, t1.Value.Day);\r
 321                         AssertEquals ("#K16", 04, t1.Value.Hour);\r
 322                         AssertEquals ("#K17", 25, t1.Value.Minute);\r
 323                         AssertEquals ("#K18", 13, t1.Value.Second);\r
 324                         \r
 325                         SqlDateTime t2 = new SqlDateTime (DateTime.Today.Year, 2, 25);\r
 326                         t1 = SqlDateTime.Parse ("February 25");\r
 327                         AssertEquals ("#K19", t2.Value.Ticks, t1.Value.Ticks);\r
 328                         \r
 329                         t2 = new SqlDateTime (DateTime.Today.Year, 2, 8);\r
 330                         t1 = SqlDateTime.Parse ("February 08");\r
 331                         AssertEquals ("#K20", t2.Value.Ticks, t1.Value.Ticks);\r
 332 \r
 333                         t1 = SqlDateTime.Parse ("Mon, 25 Feb 2002 04:25:13 GMT");\r
 334                         t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1.Value);\r
 335                         AssertEquals ("#K21", 2002, t1.Value.Year);\r
 336                         AssertEquals ("#K22", 02, t1.Value.Month);\r
 337                         AssertEquals ("#K23", 25, t1.Value.Day);\r
 338                         AssertEquals ("#K24", 04, t1.Value.Hour);\r
 339                         AssertEquals ("#K25", 25, t1.Value.Minute);\r
 340                         AssertEquals ("#K26", 13, t1.Value.Second);\r
 341 \r
 342                         t1 = SqlDateTime.Parse ("2002-02-25T05:25:13");\r
 343                         AssertEquals ("#K27", myTicks[4], t1.Value.Ticks);\r
 344 \r
 345                         t2 = DateTime.Today + new TimeSpan (5,25,0);\r
 346                         t1 = SqlDateTime.Parse ("05:25");\r
 347                         AssertEquals("#K28", t2.Value.Ticks, t1.Value.Ticks);\r
 348 \r
 349                         t2 = DateTime.Today + new TimeSpan (5,25,13);\r
 350                         t1 = SqlDateTime.Parse ("05:25:13");\r
 351                         AssertEquals("#K29", t2.Value.Ticks, t1.Value.Ticks);\r
 352 \r
 353                         t2 = new SqlDateTime (2002, 2, 1);\r
 354                         t1 = SqlDateTime.Parse ("2002 February");\r
 355                         AssertEquals ("#K30", t2.Value.Ticks, t1.Value.Ticks);\r
 356                         \r
 357                         t2 = new SqlDateTime (2002, 2, 1);\r
 358                         t1 = SqlDateTime.Parse ("2002 February");\r
 359                         AssertEquals ("#K31", t2.Value.Ticks, t1.Value.Ticks);\r
 360                         \r
 361                         t2 = new SqlDateTime (DateTime.Today.Year, 2, 8);\r
 362                         t1 = SqlDateTime.Parse ("February 8");\r
 363                         \r
 364                         AssertEquals ("#K32", t2.Value.Ticks, t1.Value.Ticks);\r
 365                 }\r
 366 \r
 367                 [Test]\r
 368                 [Ignore ("This test is locale dependent.")]\r
 369                 public void ToStringTest()\r
 370                 {\r
 371                         //\r
 372                         // Thanks for Marting Baulig for these (DateTimeTest.cs)\r
 373                         //\r
 374                         \r
 375                         SqlDateTime t1 = new SqlDateTime (2002, 2, 25, 5, 25, 13);\r
 376                         SqlDateTime t2 = new SqlDateTime (2002, 2, 25, 15, 25, 13);\r
 377                         \r
 378                         // Standard patterns\r
 379                         AssertEquals("L01", "2/25/2002 5:25:13 AM", t1.ToString ());\r
 380                         AssertEquals("L02", (SqlString)"2/25/2002 5:25:13 AM", t1.ToSqlString ());\r
 381                 }\r
 382 \r
 383                 // OPERATORS\r
 384                 [Test]\r
 385                 public void ArithmeticOperators()\r
 386                 {\r
 387                         TimeSpan TestSpan = new TimeSpan (20, 1, 20, 20);\r
 388                         SqlDateTime ResultDateTime;\r
 389 \r
 390                         // "+"-operator\r
 391                         ResultDateTime = Test1 + TestSpan;\r
 392                         AssertEquals ("#M01", 2002, ResultDateTime.Value.Year);\r
 393                         AssertEquals ("#M02", 8, ResultDateTime.Value.Day);\r
 394                         AssertEquals ("#M03", 11, ResultDateTime.Value.Hour);\r
 395                         AssertEquals ("#M04", 0, ResultDateTime.Value.Minute);\r
 396                         AssertEquals ("#M05", 20, ResultDateTime.Value.Second);     \r
 397                         Assert ("#M06", (SqlDateTime.Null + TestSpan).IsNull);\r
 398 \r
 399                         try {\r
 400                                 ResultDateTime = SqlDateTime.MaxValue + TestSpan;\r
 401                                 Fail ("#M07");\r
 402                         } catch (Exception e) {\r
 403                                 AssertEquals ("#M08", typeof (ArgumentOutOfRangeException), e.GetType ());\r
 404                         }\r
 405 \r
 406                         // "-"-operator\r
 407                         ResultDateTime = Test1 - TestSpan;\r
 408                         AssertEquals ("#M09", 2002, ResultDateTime.Value.Year);\r
 409                         AssertEquals ("#M10", 29, ResultDateTime.Value.Day);\r
 410                         AssertEquals ("#M11", 8, ResultDateTime.Value.Hour);\r
 411                         AssertEquals ("#M12", 19, ResultDateTime.Value.Minute);\r
 412                         AssertEquals ("#M13", 40, ResultDateTime.Value.Second);     \r
 413                         Assert ("#M14", (SqlDateTime.Null - TestSpan).IsNull);\r
 414                         \r
 415                         try {\r
 416                                 ResultDateTime = SqlDateTime.MinValue - TestSpan;\r
 417                                 Fail ("#M15");\r
 418                         } catch  (Exception e) {\r
 419                                 AssertEquals ("#M16", typeof (SqlTypeException), e.GetType ());\r
 420                         }\r
 421                 }\r
 422 \r
 423                 [Test]\r
 424                 public void ThanOrEqualOperators()\r
 425                 {\r
 426                         // == -operator\r
 427                         Assert ("#N01", (Test2 == Test3).Value);\r
 428                         Assert ("#N02", !(Test1 == Test2).Value);\r
 429                         Assert ("#N03", (Test1 == SqlDateTime.Null).IsNull);\r
 430                         \r
 431                         // != -operator\r
 432                         Assert ("#N04", !(Test2 != Test3).Value);\r
 433                         Assert ("#N05", (Test1 != Test3).Value);\r
 434                         Assert ("#N06", (Test1 != SqlDateTime.Null).IsNull);\r
 435 \r
 436                         // > -operator\r
 437                         Assert ("#N07", (Test2 > Test1).Value);\r
 438                         Assert ("#N08", !(Test3 > Test2).Value);\r
 439                         Assert ("#N09", (Test1 > SqlDateTime.Null).IsNull);\r
 440 \r
 441                         // >=  -operator\r
 442                         Assert ("#N10", !(Test1 >= Test3).Value);\r
 443                         Assert ("#N11", (Test3 >= Test1).Value);\r
 444                         Assert ("#N12", (Test2 >= Test3).Value);\r
 445                         Assert ("#N13", (Test1 >= SqlDateTime.Null).IsNull);\r
 446 \r
 447                         // < -operator\r
 448                         Assert ("#N14", !(Test2 < Test1).Value);\r
 449                         Assert ("#N15", (Test1 < Test3).Value);\r
 450                         Assert ("#N16", !(Test2 < Test3).Value);\r
 451                         Assert ("#N17", (Test1 < SqlDateTime.Null).IsNull);\r
 452 \r
 453                         // <= -operator\r
 454                         Assert ("#N18", (Test1 <= Test3).Value);\r
 455                         Assert ("#N19", !(Test3 <= Test1).Value);\r
 456                         Assert ("#N20", (Test2 <= Test3).Value);\r
 457                         Assert ("#N21", (Test1 <= SqlDateTime.Null).IsNull);\r
 458                 }\r
 459 \r
 460                 [Test]\r
 461                 public void SqlDateTimeToDateTime()\r
 462                 {\r
 463                         AssertEquals ("O01", 2002, ((DateTime)Test1).Year);\r
 464                         AssertEquals ("O03", 2003, ((DateTime)Test2).Year);\r
 465                         AssertEquals ("O04", 10, ((DateTime)Test1).Month);\r
 466                         AssertEquals ("O05", 19, ((DateTime)Test1).Day);\r
 467                         AssertEquals ("O06", 9, ((DateTime)Test1).Hour);\r
 468                         AssertEquals ("O07", 40, ((DateTime)Test1).Minute);\r
 469                         AssertEquals ("O08", 0, ((DateTime)Test1).Second);\r
 470                 }\r
 471 \r
 472                 [Test]\r
 473                 public void SqlStringToSqlDateTime()\r
 474                 {\r
 475 \r
 476                         SqlString TestString = new SqlString ("02/25/2002");\r
 477                         SqlDateTime t1 = (SqlDateTime)TestString;\r
 478 \r
 479                         AssertEquals ("#P01", myTicks[0], t1.Value.Ticks);\r
 480 \r
 481                         // Thanks for Martin Baulig for these (DateTimeTest.cs)\r
 482                         AssertEquals ("#P02", myTicks[0], t1.Value.Ticks);\r
 483                         t1 = (SqlDateTime) new SqlString ("Monday, 25 February 2002");\r
 484                         AssertEquals ("#P04", myTicks[0], t1.Value.Ticks);\r
 485                         t1 = (SqlDateTime) new SqlString ("Monday, 25 February 2002 05:25");\r
 486                         AssertEquals ("#P05", myTicks[3], t1.Value.Ticks);\r
 487                         t1 = (SqlDateTime) new SqlString ("Monday, 25 February 2002 05:25:13");\r
 488                         AssertEquals ("#P05", myTicks[4], t1.Value.Ticks);\r
 489                         t1 = (SqlDateTime) new SqlString ("02/25/2002 05:25");\r
 490                         AssertEquals ("#P06", myTicks[3], t1.Value.Ticks);\r
 491                         t1 = (SqlDateTime) new SqlString ("02/25/2002 05:25:13");\r
 492                         AssertEquals ("#P07", myTicks[4], t1.Value.Ticks);\r
 493                         t1 = (SqlDateTime) new SqlString ("2002-02-25 04:25:13Z");\r
 494                         t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1.Value);\r
 495                         AssertEquals ("#P08", 2002, t1.Value.Year);\r
 496                         AssertEquals ("#P09", 02, t1.Value.Month);\r
 497                         AssertEquals ("#P10", 25, t1.Value.Day);\r
 498                         AssertEquals ("#P11", 04, t1.Value.Hour);\r
 499                         AssertEquals ("#P12", 25, t1.Value.Minute);\r
 500                         AssertEquals ("#P13", 13, t1.Value.Second);\r
 501                         \r
 502                         SqlDateTime t2 = new SqlDateTime (DateTime.Today.Year, 2, 25);\r
 503                         t1 = (SqlDateTime) new SqlString ("February 25");\r
 504                         AssertEquals ("#P14", t2.Value.Ticks, t1.Value.Ticks);\r
 505                         \r
 506                         t2 = new SqlDateTime (DateTime.Today.Year, 2, 8);\r
 507                         t1 = (SqlDateTime) new SqlString ("February 08");\r
 508                         AssertEquals ("#P15", t2.Value.Ticks, t1.Value.Ticks);\r
 509 \r
 510                         t1 = (SqlDateTime) new SqlString ("Mon, 25 Feb 2002 04:25:13 GMT");\r
 511                         t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1.Value);\r
 512                         AssertEquals ("#P16", 2002, t1.Value.Year);\r
 513                         AssertEquals ("#P17", 02, t1.Value.Month);\r
 514                         AssertEquals ("#P18", 25, t1.Value.Day);\r
 515                         AssertEquals ("#P19", 04, t1.Value.Hour);\r
 516                         AssertEquals ("#P20", 25, t1.Value.Minute);\r
 517                         AssertEquals ("#P21", 13, t1.Value.Second);\r
 518 \r
 519                         t1 = (SqlDateTime) new SqlString ("2002-02-25T05:25:13");\r
 520                         AssertEquals ("#P22", myTicks[4], t1.Value.Ticks);\r
 521 \r
 522                         t2 = DateTime.Today + new TimeSpan (5,25,0);\r
 523                         t1 = (SqlDateTime) new SqlString ("05:25");\r
 524                         AssertEquals("#P23", t2.Value.Ticks, t1.Value.Ticks);\r
 525 \r
 526                         t2 = DateTime.Today + new TimeSpan (5,25,13);\r
 527                         t1 = (SqlDateTime) new SqlString ("05:25:13");\r
 528                         AssertEquals("#P24", t2.Value.Ticks, t1.Value.Ticks);\r
 529 \r
 530                         t2 = new SqlDateTime (2002, 2, 1);\r
 531                         t1 = (SqlDateTime) new SqlString ("2002 February");\r
 532                         AssertEquals ("#P25", t2.Value.Ticks, t1.Value.Ticks);\r
 533                         \r
 534                         t2 = new SqlDateTime (2002, 2, 1);\r
 535                         t1 = (SqlDateTime) new SqlString ("2002 February");\r
 536                         AssertEquals ("#P26", t2.Value.Ticks, t1.Value.Ticks);\r
 537                         \r
 538                         t2 = new SqlDateTime (DateTime.Today.Year, 2, 8);\r
 539                         t1 = (SqlDateTime) new SqlString ("February 8");\r
 540                         \r
 541                         AssertEquals ("#P27", t2.Value.Ticks, t1.Value.Ticks);\r
 542                 }\r
 543 \r
 544                 [Test]\r
 545                 public void DateTimeToSqlDateTime()\r
 546                 {\r
 547                         DateTime DateTimeTest = new DateTime (2002, 10, 19, 11, 53, 4);\r
 548                         SqlDateTime Result = (SqlDateTime)DateTimeTest;\r
 549                         AssertEquals ("#Q01", 2002, Result.Value.Year);\r
 550                         AssertEquals ("#Q02", 10, Result.Value.Month);\r
 551                         AssertEquals ("#Q03", 19, Result.Value.Day);\r
 552                         AssertEquals ("#Q04", 11, Result.Value.Hour);\r
 553                         AssertEquals ("#Q05", 53, Result.Value.Minute);\r
 554                         AssertEquals ("#Q06", 4, Result.Value.Second);\r
 555                 }\r
 556         }\r
 557 }\r
 558 \r