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

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