mcs/class/Microsoft.VisualBasic/Test/Microsoft.VisualBasic/DateAndTimeTest.cs

   1 // DateAndTimeTest.cs - NUnit Test Cases for Microsoft.VisualBasic.DateAndTime
   2 //
   3 // Authors:
   4 //   Chris J. Breisch (cjbreisch@altavista.net)
   5 //   Martin Willemoes Hansen (mwh@sysrq.dk)
   6 //
   7 // (C) Chris J. Breisch
   8 // (C) Martin Willemoes Hansen
   9 //
  10
  11 //
  12 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  13 //
  14 // Permission is hereby granted, free of charge, to any person obtaining
  15 // a copy of this software and associated documentation files (the
  16 // "Software"), to deal in the Software without restriction, including
  17 // without limitation the rights to use, copy, modify, merge, publish,
  18 // distribute, sublicense, and/or sell copies of the Software, and to
  19 // permit persons to whom the Software is furnished to do so, subject to
  20 // the following conditions:
  21 //
  22 // The above copyright notice and this permission notice shall be
  23 // included in all copies or substantial portions of the Software.
  24 //
  25 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  29 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  30 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  31 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  32 //
  33
  34 using NUnit.Framework;
  35 using System;
  36 using System.Threading;
  37 using System.Globalization;
  38 using Microsoft.VisualBasic;
  39
  40 namespace MonoTests.Microsoft.VisualBasic
  41 {
  42         [TestFixture]
  43         public class DateAndTimeTest : Assertion {
  44
  45                 private CultureInfo oldcult;
  46
  47                 [SetUp]
  48                 public void GetReady()
  49                 {
  50                         // the current culture determines the result of formatting
  51                         oldcult = Thread.CurrentThread.CurrentCulture;
  52                         Thread.CurrentThread.CurrentCulture = new CultureInfo ("");
  53                 }
  54
  55                 [TearDown]
  56                 public void Clear()
  57                 {
  58                         Thread.CurrentThread.CurrentCulture = oldcult;
  59                 }
  60
  61                 [Test]
  62                 public void DateString()
  63                 {
  64                         string s = DateAndTime.DateString;
  65                         DateTime dtNow = DateTime.Today;
  66                         AssertEquals("#DS01", dtNow.ToShortDateString(), DateTime.Parse(s).ToShortDateString());
  67
  68                         // TODO: Add a test for setting the date string too
  69                 }
  70
  71                 [Test]
  72                 public void Today()
  73                 {
  74                         AssertEquals("#TO01", DateTime.Today, DateAndTime.Today);
  75
  76                         // TODO: Add a test for setting Today
  77                 }
  78
  79                 [Test]
  80                 public void Timer()
  81                 {
  82                         double secTimer = DateAndTime.Timer;
  83                         DateTime dtNow = DateTime.Now;
  84                         double secNow = dtNow.Hour * 3600 + dtNow.Minute * 60 + dtNow.Second + (dtNow.Millisecond + 1) / 1000D;
  85                         double secTimer2 = DateAndTime.Timer + .002D; // before was .001; but we need to allow for rounding differences
  86
  87                         // waste a little time
  88                         for (int i = 0; i < int.MaxValue; i++);
  89
  90                         // get another timer
  91                         double secTimer3 = DateAndTime.Timer;
  92
  93                         // should be same time within a reasonable tolerance
  94                         Assert("#TI01", secNow >= secTimer);
  95                         Assert("#TI02: slacked SecTimer2=" + secTimer2 + " secNow=" + secNow, secTimer2 >= secNow);
  96
  97                         // third timer should be greater than the first
  98                         Assert("#TI03", secTimer3 > secTimer);
  99                 }
 100
 101                 [Test]
 102                 public void Now()
 103                 {
 104                         DateTime dtNow = DateTime.Now;
 105                         DateTime dtTest = DateAndTime.Now;
 106                         DateTime dtNow2 = DateTime.Now;
 107
 108                         Assert("#N01", dtTest >= dtNow);
 109                         Assert("#N02", dtNow2 >= dtTest);
 110                 }
 111
 112                 [Test]
 113                 public void TimeOfDay()
 114                 {
 115                         DateTime dtNow = DateTime.Now;
 116                         TimeSpan tsNow = new TimeSpan(dtNow.Hour, dtNow.Minute, dtNow.Second);
 117                         DateTime dtTest = DateAndTime.TimeOfDay;
 118                         TimeSpan tsTest = new TimeSpan(dtTest.Hour, dtTest.Minute, dtTest.Second);
 119                         DateTime dtNow2 = DateTime.Now;
 120                         TimeSpan tsNow2 = new TimeSpan(dtNow2.Hour, dtNow2.Minute, dtNow2.Second);
 121
 122                         Assert("#TOD01", tsTest.Ticks >= tsNow.Ticks);
 123                         Assert("#TOD02", tsNow2.Ticks >= tsTest.Ticks);
 124
 125                         // TODO: add a test case for setting time of day
 126                 }
 127
 128                 [Test]
 129                 public void TimeString()
 130                 {
 131                         DateTime dtNow = DateTime.Now;
 132                         TimeSpan tsNow = new TimeSpan(dtNow.Hour, dtNow.Minute, dtNow.Second);
 133                         string s = DateAndTime.TimeString;
 134                         DateTime dtTest = DateTime.Parse(s);
 135                         TimeSpan tsTest = new TimeSpan(dtTest.Hour, dtTest.Minute, dtTest.Second);
 136                         DateTime dtNow2 = DateTime.Now;
 137                         TimeSpan tsNow2 = new TimeSpan(dtNow2.Hour, dtNow2.Minute, dtNow2.Second);
 138
 139                         Assert("#TS01", tsTest.Ticks >= tsNow.Ticks);
 140                         Assert("#TS02", tsNow2.Ticks >= tsTest.Ticks);
 141
 142                         // TODO: add a test case for setting TimeString
 143                 }
 144
 145                 [Test]
 146                 public void DateAdd()
 147                 {
 148                         DateTime dtNow = DateTime.Now;
 149
 150                         AssertEquals("#DA01", dtNow.AddYears(1), DateAndTime.DateAdd(DateInterval.Year, 1, dtNow));
 151                         AssertEquals("#DA02", dtNow.AddYears(-1), DateAndTime.DateAdd("yyyy", -1, dtNow));
 152
 153
 154                         bool caughtException = false;
 155
 156                         try {
 157                                 DateAndTime.DateAdd("foo", 1, dtNow);
 158                         }
 159                         catch (Exception e) {
 160                                 AssertEquals("#DA03", e.GetType(), typeof(ArgumentException));
 161                                 caughtException = true;
 162                         }
 163
 164                         AssertEquals("#DA04", caughtException, true);
 165
 166                         AssertEquals("#DA05", dtNow.AddMonths(6), DateAndTime.DateAdd(DateInterval.Quarter, 2, dtNow));
 167                         AssertEquals("#DA06", dtNow.AddMonths(-6), DateAndTime.DateAdd("q", -2, dtNow));
 168
 169                         AssertEquals("#DA07", dtNow.AddMonths(3), DateAndTime.DateAdd(DateInterval.Month, 3, dtNow));
 170                         AssertEquals("#DA08", dtNow.AddMonths(-3), DateAndTime.DateAdd("m", -3, dtNow));
 171
 172                         AssertEquals("#DA09", dtNow.AddDays(28), DateAndTime.DateAdd(DateInterval.WeekOfYear, 4, dtNow));
 173                         AssertEquals("#DA10", dtNow.AddDays(-28), DateAndTime.DateAdd("ww", -4, dtNow));
 174
 175                         AssertEquals("#DA11", dtNow.AddDays(5), DateAndTime.DateAdd(DateInterval.Weekday, 5, dtNow));
 176                         AssertEquals("#DA12", dtNow.AddDays(-5), DateAndTime.DateAdd("w", -5, dtNow));
 177
 178                         AssertEquals("#DA13", dtNow.AddDays(6), DateAndTime.DateAdd(DateInterval.DayOfYear, 6, dtNow));
 179                         AssertEquals("#DA14", dtNow.AddDays(-6), DateAndTime.DateAdd("y", -6, dtNow));
 180
 181                         AssertEquals("#DA15", dtNow.AddDays(7), DateAndTime.DateAdd(DateInterval.Day, 7, dtNow));
 182                         AssertEquals("#DA16", dtNow.AddDays(-7), DateAndTime.DateAdd("d", -7, dtNow));
 183
 184                         AssertEquals("#DA17", dtNow.AddHours(8), DateAndTime.DateAdd(DateInterval.Hour, 8, dtNow));
 185                         AssertEquals("#DA18", dtNow.AddHours(-8), DateAndTime.DateAdd(DateInterval.Hour, -8, dtNow));
 186
 187                         AssertEquals("#DA19", dtNow.AddMinutes(9), DateAndTime.DateAdd(DateInterval.Minute, 9, dtNow));
 188                         AssertEquals("#DA20", dtNow.AddMinutes(-9), DateAndTime.DateAdd("n", -9, dtNow));
 189
 190                         AssertEquals("#DA21", dtNow.AddSeconds(10), DateAndTime.DateAdd(DateInterval.Second, 10, dtNow));
 191                         AssertEquals("#DA22", dtNow.AddSeconds(-10), DateAndTime.DateAdd("s", -10, dtNow));
 192
 193                         caughtException = false;
 194
 195                         try {
 196                                 DateAndTime.DateAdd(DateInterval.Year, int.MinValue, dtNow);
 197                         }
 198                         catch (Exception e) {
 199                                 caughtException = true;
 200                                 AssertEquals("#DA23", e.GetType(), typeof(Exception));
 201                         }
 202
 203                         // AssertEquals("#DA24", caughtException, true);
 204                 }
 205
 206                 [Test]
 207                 public void DateDiff ()
 208                 {
 209                         DateTime dtNow = DateTime.Now;
 210                         DateTime dtOld = dtNow.AddYears(-1);
 211
 212                         // TODO: Test this better
 213                         long diff = DateAndTime.DateDiff(DateInterval.Year, dtOld, dtNow, FirstDayOfWeek.System, FirstWeekOfYear.System);
 214
 215                         AssertEquals("#DD01", dtNow, dtOld.AddYears((int)diff));
 216
 217                         DateTime dtJan1 = new DateTime(2002, 1, 1);
 218                         DateTime dtDec31 = new DateTime(2001, 12, 31);
 219
 220                         diff = DateAndTime.DateDiff(DateInterval.Year, dtDec31, dtJan1, FirstDayOfWeek.System, FirstWeekOfYear.System);
 221
 222                         AssertEquals("#DD02", 1L, diff);
 223
 224                         diff = DateAndTime.DateDiff(DateInterval.Quarter, dtDec31, dtJan1, FirstDayOfWeek.System, FirstWeekOfYear.System);
 225
 226                         AssertEquals("#DD03", 1L, diff);
 227
 228                         diff = DateAndTime.DateDiff(DateInterval.Month, dtDec31, dtJan1, FirstDayOfWeek.System, FirstWeekOfYear.System);
 229
 230                         AssertEquals("#DD04", 1L, diff);
 231
 232                         DateTime dtJan4 = new DateTime(2001, 1, 4);     // This is a Thursday
 233                         DateTime dtJan9 = new DateTime(2001, 1, 9);     // This is the next Tuesday
 234
 235
 236                         long WD = DateAndTime.DateDiff(DateInterval.Weekday, dtJan4, dtJan9, FirstDayOfWeek.System, FirstWeekOfYear.System);
 237
 238                         AssertEquals ("#DD05", 0L, WD);
 239
 240                         long WY = DateAndTime.DateDiff(DateInterval.WeekOfYear, dtJan4, dtJan9, FirstDayOfWeek.System, FirstWeekOfYear.System);
 241
 242                         AssertEquals ("#DD06", 1L, WY);
 243                 }
 244
 245                 [Test]
 246                 public void DatePart ()
 247                 {
 248                         DateTime dtJan4 = new DateTime(2001, 1, 4);
 249
 250                         // TODO: Test this better
 251
 252                         AssertEquals("#DP01", 2001, DateAndTime.DatePart(DateInterval.Year, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.System));
 253                         AssertEquals("#DP02", 1, DateAndTime.DatePart(DateInterval.Quarter, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.System));
 254                         AssertEquals("#DP03", 1, DateAndTime.DatePart(DateInterval.Month, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.System));
 255                         AssertEquals("#DP04", 1, DateAndTime.DatePart(DateInterval.WeekOfYear, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.FirstFourDays));
 256                         AssertEquals("#DP05", 53, DateAndTime.DatePart(DateInterval.WeekOfYear, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.FirstFullWeek));
 257                         AssertEquals("#DP06", 1, DateAndTime.DatePart(DateInterval.WeekOfYear, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.Jan1));
 258                         AssertEquals("#DP07", 1, DateAndTime.DatePart(DateInterval.WeekOfYear, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.System));
 259                         AssertEquals("#DP08", 7, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.Friday, FirstWeekOfYear.FirstFourDays));
 260                         AssertEquals("#DP09", 6, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.Saturday, FirstWeekOfYear.FirstFourDays));
 261                         AssertEquals("#DP10", 5, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.Sunday, FirstWeekOfYear.FirstFourDays));
 262                         AssertEquals("#DP11", 4, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.Monday, FirstWeekOfYear.FirstFourDays));
 263                         AssertEquals("#DP12", 3, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.Tuesday, FirstWeekOfYear.FirstFourDays));
 264                         AssertEquals("#DP13", 2, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.Wednesday, FirstWeekOfYear.FirstFourDays));
 265                         AssertEquals("#DP14", 1, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.Thursday, FirstWeekOfYear.FirstFourDays));
 266                         AssertEquals("#DP15", 5, DateAndTime.DatePart(DateInterval.Weekday, dtJan4, FirstDayOfWeek.System, FirstWeekOfYear.FirstFourDays));
 267
 268
 269                 }
 270
 271                 [Test]
 272                 public void DateSerial ()
 273                 {
 274                         DateTime dtJan4 = new DateTime(2001, 1, 4);
 275                         DateTime dtSerial = DateAndTime.DateSerial(2001, 1, 4);
 276
 277                         AssertEquals("#DS01", dtJan4, dtSerial);
 278                 }
 279
 280                 [Test]
 281                 public void TimeSerial ()
 282                 {
 283                         bool caughtException = false;
 284
 285                         try {
 286                                 DateAndTime.TimeSerial(0, -1440, -1);
 287                         }
 288                         catch (Exception e) {
 289                                 AssertEquals("#TS01", e.GetType(), typeof(ArgumentOutOfRangeException));
 290                                 caughtException = true;
 291                         }
 292                         AssertEquals("#TS02", true, caughtException);
 293
 294                         AssertEquals("#TS03", new DateTime(1, 1, 1, 1, 1, 1), DateAndTime.TimeSerial(1, 1, 1));
 295
 296                 }
 297
 298                 [Test]
 299                 public void DateValue ()
 300                 {
 301                         try {
 302                                 DateAndTime.DateValue("This is not a date.");
 303                         }
 304                         catch (InvalidCastException) {
 305                                 /* do nothing.  this is what we expect */
 306                         }
 307                         catch (Exception e) {
 308                                 Fail ("Unexpected exception:" + e);
 309                         }
 310                         AssertEquals("#DV03", new DateTime(1969, 2, 12), DateAndTime.DateValue("02/12/1969"));
 311                         AssertEquals("#DV04", new DateTime(1969, 2, 12), DateAndTime.DateValue("February 12, 1969"));
 312                 }
 313
 314                 [Test]
 315                 public void TimeValue ()
 316                 {
 317                         try {
 318                                 DateAndTime.TimeValue("This is not a time.");
 319                         }
 320                         catch (InvalidCastException) {
 321                                 /* do nothing.  this is what we expect */
 322                         }
 323                         catch (Exception e) {
 324                                 Fail ("Unexpected exception:" + e);
 325                         }
 326                         AssertEquals("#TV03", new DateTime(1, 1, 1, 16, 35, 17), DateAndTime.TimeValue("16:35:17")); // works in .NET?
 327                         AssertEquals("#TV04", new DateTime(1, 1, 1, 16, 35, 17), DateAndTime.TimeValue("4:35:17 PM"));
 328                 }
 329
 330                 [Test]
 331                 public void Year ()
 332                 {
 333                         DateTime jan1 = new DateTime(2001, 1, 1, 1, 1, 1);
 334                         AssertEquals("#Y01", jan1.Year, DateAndTime.Year(jan1));
 335                 }
 336
 337                 [Test]
 338                 public void Month ()
 339                 {
 340                         DateTime jan1 = new DateTime(2001, 1, 1, 1, 1, 1);
 341                         AssertEquals("#MO01", jan1.Month, DateAndTime.Month(jan1));
 342                 }
 343
 344                 [Test]
 345                 public void Day ()
 346                 {
 347                         DateTime jan1 = new DateTime(2001, 1, 1, 1, 1, 1);
 348                         AssertEquals("#D01", jan1.Day, DateAndTime.Day(jan1));
 349                 }
 350
 351                 [Test]
 352                 public void Hour ()
 353                 {
 354                         DateTime jan1 = new DateTime(2001, 1, 1, 1, 1, 1);
 355                         AssertEquals("#H01", jan1.Hour, DateAndTime.Hour(jan1));
 356                 }
 357
 358                 [Test]
 359                 public void Minute ()
 360                 {
 361                         DateTime jan1 = new DateTime(2001, 1, 1, 1, 1, 1);
 362                         AssertEquals("#MI01", jan1.Minute, DateAndTime.Minute(jan1));
 363                 }
 364
 365                 [Test]
 366                 public void Second ()
 367                 {
 368                         DateTime jan1 = new DateTime(2001, 1, 1, 1, 1, 1);
 369                         AssertEquals("#S01", jan1.Second, DateAndTime.Second(jan1));
 370                 }
 371
 372                 [Test]
 373                 public void Weekday ()
 374                 {
 375                         DateTime jan1 = new DateTime(2001, 1, 1, 1, 1, 1);
 376                         AssertEquals("#W01", (int)jan1.DayOfWeek + 1, DateAndTime.Weekday(jan1, FirstDayOfWeek.System));
 377                 }
 378
 379                 [Test]
 380                 public void MonthName ()
 381                 {
 382                         DateTime jan1 = new DateTime(2001, 1, 1, 1, 1, 1);
 383                         AssertEquals("#MN01", CultureInfo.CurrentCulture.DateTimeFormat.GetAbbreviatedMonthName(jan1.Month),
 384                                 DateAndTime.MonthName(jan1.Month, true));
 385                         AssertEquals("#MN02", CultureInfo.CurrentCulture.DateTimeFormat.GetMonthName(jan1.Month),
 386                                 DateAndTime.MonthName(jan1.Month, false));
 387
 388                         bool caughtException = false;
 389
 390                         try {
 391                                 DateAndTime.MonthName(0, false);
 392                         }
 393                         catch (Exception e) {
 394                                 AssertEquals("#MN03", typeof(ArgumentException), e.GetType());
 395                                 caughtException = true;
 396                         }
 397                         AssertEquals("#MN04", true, caughtException);
 398
 399                         caughtException = false;
 400
 401                         try {
 402                                 DateAndTime.MonthName(14, false);
 403                         }
 404                         catch (Exception e) {
 405                                 AssertEquals("#MN05", typeof(ArgumentException), e.GetType());
 406                                 caughtException = true;
 407                         }
 408                         AssertEquals("#MN06", true, caughtException);
 409
 410                         //AssertEquals("#MN07", "", DateAndTime.MonthName(13, false));
 411                 }
 412
 413                 [Test]
 414                 public void WeekdayName ()
 415                 {
 416                         DateTime jan1 = new DateTime(2001, 1, 1, 1, 1, 1);
 417                         AssertEquals("#WN01", "Tue",
 418                                 DateAndTime.WeekdayName((int)jan1.DayOfWeek + 1, true, FirstDayOfWeek.Monday));
 419                         AssertEquals("#WN02", "Tuesday",
 420                                 DateAndTime.WeekdayName((int)jan1.DayOfWeek + 1, false, FirstDayOfWeek.Monday));
 421
 422                         bool caughtException = false;
 423
 424                         try {
 425                                 DateAndTime.WeekdayName(0, false, FirstDayOfWeek.Monday);
 426                         }
 427                         catch (Exception e) {
 428                                 AssertEquals("#WN03", typeof(ArgumentException), e.GetType());
 429                                 caughtException = true;
 430                         }
 431                         AssertEquals("#WN04", true, caughtException);
 432
 433                         caughtException = false;
 434
 435                         try {
 436                                 DateAndTime.WeekdayName(8, false, FirstDayOfWeek.Monday);
 437                         }
 438                         catch (Exception e) {
 439                                 AssertEquals("#WN05", typeof(ArgumentException), e.GetType());
 440                                 caughtException = true;
 441                         }
 442                         AssertEquals("#WN06", true, caughtException);
 443
 444                         AssertEquals("#WN07", "Tuesday", DateAndTime.WeekdayName((int)jan1.DayOfWeek + 1, false, FirstDayOfWeek.Monday));
 445                 }
 446         }
 447 }