mcs/class/corlib/Test/System/TimeSpanTest.cs

   1 //
   2 // TimeSpanTest.cs - NUnit Test Cases for the System.TimeSpan struct
   3 //
   4 // author:
   5 //   Duco Fijma (duco@lorentz.xs4all.nl)
   6 //
   7 //   (C) 2001 Duco Fijma
   8 //
   9
  10 using NUnit.Framework;
  11 using System;
  12
  13 namespace MonoTests.System
  14 {
  15
  16 public class TimeSpanTest : TestCase
  17 {
  18         public TimeSpanTest() {}
  19
  20         public void TestCtors ()
  21         {
  22                 TimeSpan t1 = new TimeSpan (1234567890);
  23
  24                 AssertEquals ("A1", "00:02:03.4567890", t1.ToString ());
  25                 t1 = new TimeSpan (1,2,3);
  26                 AssertEquals ("A2", "01:02:03", t1.ToString ());
  27                 t1 = new TimeSpan (1,2,3,4);
  28                 AssertEquals ("A3", "1.02:03:04", t1.ToString ());
  29                 t1 = new TimeSpan (1,2,3,4,5);
  30                 AssertEquals ("A4", "1.02:03:04.0050000", t1.ToString ());
  31                 t1 = new TimeSpan (-1,2,-3,4,-5);
  32                 AssertEquals ("A5", "-22:02:56.0050000", t1.ToString ());
  33                 t1 = new TimeSpan (0,25,0,0,0);
  34                 AssertEquals ("A6", "1.01:00:00", t1.ToString ());
  35         }
  36
  37         public void TestProperties ()
  38         {
  39                 TimeSpan t1 = new TimeSpan (1,2,3,4,5);
  40                 TimeSpan t2 = -t1;
  41
  42                 AssertEquals ("A1", 1, t1.Days);
  43                 AssertEquals ("A2", 2, t1.Hours);
  44                 AssertEquals ("A3", 3, t1.Minutes);
  45                 AssertEquals ("A4", 4, t1.Seconds);
  46                 AssertEquals ("A5", 5, t1.Milliseconds);
  47                 AssertEquals ("A6", -1, t2.Days);
  48                 AssertEquals ("A7", -2, t2.Hours);
  49                 AssertEquals ("A8", -3, t2.Minutes);
  50                 AssertEquals ("A9", -4, t2.Seconds);
  51                 AssertEquals ("A10", -5, t2.Milliseconds);
  52         }
  53
  54         public void TestAdd ()
  55         {
  56                 TimeSpan t1 = new TimeSpan (2,3,4,5,6);
  57                 TimeSpan t2 = new TimeSpan (1,2,3,4,5);
  58                 TimeSpan t3 = t1 + t2;
  59                 TimeSpan t4 = t1.Add (t2);
  60                 TimeSpan t5;
  61                 bool exception;
  62
  63                 AssertEquals ("A1", 3, t3.Days);
  64                 AssertEquals ("A2", 5, t3.Hours);
  65                 AssertEquals ("A3", 7, t3.Minutes);
  66                 AssertEquals ("A4", 9, t3.Seconds);
  67                 AssertEquals ("A5", 11, t3.Milliseconds);
  68                 AssertEquals ("A6", "3.05:07:09.0110000", t4.ToString ());
  69                 try
  70                 {
  71                         t5 = TimeSpan.MaxValue + new TimeSpan (1);
  72                         exception = false;
  73                 }
  74                 catch (OverflowException)
  75                 {
  76                         exception = true;
  77                 }
  78                 Assert ("A7", exception);
  79         }
  80
  81         public void TestCompare ()
  82         {
  83                 TimeSpan t1 = new TimeSpan (-1);
  84                 TimeSpan t2 = new TimeSpan (1);
  85                 int res;
  86                 bool exception;
  87
  88                 AssertEquals ("A1", -1, TimeSpan.Compare (t1, t2));
  89                 AssertEquals ("A2", 1, TimeSpan.Compare (t2, t1));
  90                 AssertEquals ("A3", 0, TimeSpan.Compare (t2, t2));
  91                 AssertEquals ("A4", -1, TimeSpan.Compare (TimeSpan.MinValue, TimeSpan.MaxValue));
  92                 AssertEquals ("A5", -1, t1.CompareTo (t2));
  93                 AssertEquals ("A6", 1, t2.CompareTo (t1));
  94                 AssertEquals ("A7", 0, t2.CompareTo (t2));
  95                 AssertEquals ("A8", -1, TimeSpan.Compare (TimeSpan.MinValue, TimeSpan.MaxValue));
  96
  97                 AssertEquals ("A9", 1, TimeSpan.Zero.CompareTo (null));
  98
  99                 try
 100                 {
 101                         res = TimeSpan.Zero.CompareTo("");
 102                         exception = false;
 103                 }
 104                 catch (ArgumentException)
 105                 {
 106                         exception = true;
 107                 }
 108                 Assert ("A10", exception);
 109
 110                 AssertEquals ("A11", false, t1 == t2);
 111                 AssertEquals ("A12", false, t1 > t2);
 112                 AssertEquals ("A13", false, t1 >= t2);
 113                 AssertEquals ("A14", true, t1 != t2);
 114                 AssertEquals ("A15", true, t1 < t2);
 115                 AssertEquals ("A16", true, t1 <= t2);
 116         }
 117
 118         [Test]
 119         [ExpectedException (typeof (OverflowException))]
 120         public void NoNegateMinValue() {
 121                 TimeSpan t1 = TimeSpan.MinValue.Negate ();
 122         }
 123
 124         public void TestNegateAndDuration ()
 125         {
 126                 TimeSpan t1;
 127                 bool exception;
 128
 129                 AssertEquals ("A1", "-00:00:00.0012345", new TimeSpan (12345).Negate ().ToString ());
 130                 AssertEquals ("A2", "00:00:00.0012345", new TimeSpan (-12345).Duration ().ToString ());
 131
 132                 try
 133                 {
 134                         t1 = TimeSpan.MinValue.Duration ();
 135                         exception = false;
 136                 }
 137                 catch (OverflowException) {
 138                         exception = true;
 139                 }
 140                 Assert ("A4", exception);
 141
 142                 AssertEquals ("A5", "-00:00:00.0000077", (-(new TimeSpan (77))).ToString ());
 143                 AssertEquals("A6", "00:00:00.0000077", (+(new TimeSpan(77))).ToString());
 144         }
 145
 146         public void TestEquals ()
 147         {
 148                 TimeSpan t1 = new TimeSpan (1);
 149                 TimeSpan t2 = new TimeSpan (2);
 150                 string s = "justastring";
 151
 152                 AssertEquals ("A1", true, t1.Equals (t1));
 153                 AssertEquals ("A2", false, t1.Equals (t2));
 154                 AssertEquals ("A3", false, t1.Equals (s));
 155                 AssertEquals ("A4", false, t1.Equals (null));
 156                 AssertEquals ("A5", true, TimeSpan.Equals (t1, t1));
 157                 AssertEquals ("A6", false, TimeSpan.Equals (t1, t2));
 158                 AssertEquals ("A7", false, TimeSpan.Equals (t1, null));
 159                 AssertEquals ("A8", false, TimeSpan.Equals (t1, s));
 160                 AssertEquals ("A9", false, TimeSpan.Equals (s, t2));
 161                 AssertEquals ("A10", true, TimeSpan.Equals (null,null));
 162         }
 163
 164         public void TestFromXXXX ()
 165         {
 166                 AssertEquals ("A1", "12.08:16:48", TimeSpan.FromDays (12.345).ToString ());
 167                 AssertEquals ("A2", "12:20:42", TimeSpan.FromHours (12.345).ToString ());
 168                 AssertEquals ("A3", "00:12:20.7000000", TimeSpan.FromMinutes (12.345).ToString ());
 169                 AssertEquals ("A4", "00:00:12.3450000", TimeSpan.FromSeconds (12.345).ToString ());
 170                 AssertEquals ("A5", "00:00:00.0120000", TimeSpan.FromMilliseconds (12.345).ToString ());
 171                 AssertEquals ("A6", "00:00:00.0012345", TimeSpan.FromTicks (12345).ToString ());
 172         }
 173
 174         public void TestGetHashCode ()
 175         {
 176                 AssertEquals ("A1", 77, new TimeSpan (77).GetHashCode ());
 177         }
 178
 179         private void ParseHelper (string s, bool expectFormat, bool expectOverflow, string expect)
 180         {
 181                 bool formatException = false;
 182                 bool overflowException = false;
 183                 string result = "junk ";
 184
 185                 try {
 186                         result =  TimeSpan.Parse (s).ToString ();
 187                 }
 188                 catch (OverflowException) {
 189                         overflowException = true;
 190                 }
 191                 catch (FormatException) {
 192                         formatException = true;
 193                 }
 194                 AssertEquals ("A1", expectFormat, formatException);
 195                 AssertEquals ("A2", expectOverflow, overflowException);
 196
 197                 if (!expectOverflow && !expectFormat) {
 198                         AssertEquals ("A3", expect, result);
 199                 }
 200         }
 201
 202         public void TestParse ()
 203         {
 204                 ParseHelper (" 13:45:15 ",false, false, "13:45:15");
 205                 ParseHelper (" -1:2:3 ", false, false, "-01:02:03");
 206
 207                 ParseHelper (" 25:0:0 ",false, true, "dontcare");
 208                 ParseHelper ("aaa", true, false, "dontcare");
 209
 210                 ParseHelper ("-21.23:59:59.9999999", false, false, "-21.23:59:59.9999999");
 211
 212                 ParseHelper ("100000000000000.1:1:1", false, true, "dontcare");
 213                 ParseHelper ("24:60:60", false, true, "dontcare");
 214                 ParseHelper ("0001:0002:0003.12     ", false, false, "01:02:03.1200000");
 215
 216                 ParseHelper (" 1:2:3:12345678 ", true, false, "dontcare");
 217         }
 218
 219         public void TestSubstract ()
 220         {
 221                 TimeSpan t1 = new TimeSpan (2,3,4,5,6);
 222                 TimeSpan t2 = new TimeSpan (1,2,3,4,5);
 223                 TimeSpan t3 = t1 - t2;
 224                 TimeSpan t4 = t1.Subtract (t2);
 225                 TimeSpan t5;
 226                 bool exception;
 227
 228                 AssertEquals ("A1", "1.01:01:01.0010000", t3.ToString ());
 229                 AssertEquals ("A2", "1.01:01:01.0010000", t4.ToString ());
 230                 try {
 231                         t5 = TimeSpan.MinValue - new TimeSpan (1);
 232                         exception = false;
 233                 }
 234                 catch (OverflowException) {
 235                         exception = true;
 236                 }
 237                 Assert ("A3", exception);
 238         }
 239
 240         public void TestToString ()
 241         {
 242                 TimeSpan t1 = new TimeSpan (1,2,3,4,5);
 243                 TimeSpan t2 = -t1;
 244
 245                 AssertEquals ("A1", "1.02:03:04.0050000", t1.ToString ());
 246                 AssertEquals ("A2", "-1.02:03:04.0050000", t2.ToString ());
 247                 AssertEquals ("A3", "10675199.02:48:05.4775807", TimeSpan.MaxValue.ToString ());
 248                 AssertEquals ("A4", "-10675199.02:48:05.4775808", TimeSpan.MinValue.ToString ());
 249         }
 250
 251 }
 252
 253 }