1 // Licensed to the .NET Foundation under one or more agreements.
2 // See the LICENSE file in the project root for more information.
3 
4 // (C) 2002 Ville Palo
5 // (C) 2003 Martin Willemoes Hansen
6 
7 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
8 //
9 // Permission is hereby granted, free of charge, to any person obtaining
10 // a copy of this software and associated documentation files (the
11 // "Software"), to deal in the Software without restriction, including
12 // without limitation the rights to use, copy, modify, merge, publish,
13 // distribute, sublicense, and/or sell copies of the Software, and to
14 // permit persons to whom the Software is furnished to do so, subject to
15 // the following conditions:
16 //
17 // The above copyright notice and this permission notice shall be
18 // included in all copies or substantial portions of the Software.
19 //
20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 
28 using Xunit;
29 using System.Xml;
30 using System.Data.SqlTypes;
31 using System.Globalization;
32 
33 namespace System.Data.Tests.SqlTypes
34 {
35     public class SqlDateTimeTest
36     {
37         private long[] _myTicks = {
38             631501920000000000L,	// 25 Feb 2002 - 00:00:00
39 			631502475130080000L,	// 25 Feb 2002 - 15:25:13,8
40 			631502115130080000L,	// 25 Feb 2002 - 05:25:13,8
41 			631502115000000000L,	// 25 Feb 2002 - 05:25:00
42 			631502115130000000L,	// 25 Feb 2002 - 05:25:13
43 			631502079130000000L,	// 25 Feb 2002 - 04:25:13
44 			629197085770000000L	// 06 Nov 1994 - 08:49:37
45 		};
46 
47         private SqlDateTime _test1;
48         private SqlDateTime _test2;
49         private SqlDateTime _test3;
50 
SqlDateTimeTest()51         public SqlDateTimeTest()
52         {
53             _test1 = new SqlDateTime(2002, 10, 19, 9, 40, 0);
54             _test2 = new SqlDateTime(2003, 11, 20, 10, 50, 1);
55             _test3 = new SqlDateTime(2003, 11, 20, 10, 50, 1);
56         }
57 
58         // Test constructor
59         [Fact]
Create()60         public void Create()
61         {
62             // SqlDateTime (DateTime)
63             SqlDateTime CTest = new SqlDateTime(
64                 new DateTime(2002, 5, 19, 3, 34, 0));
65             Assert.Equal(2002, CTest.Value.Year);
66 
67             // SqlDateTime (int, int)
68             CTest = new SqlDateTime(0, 0);
69 
70             // SqlDateTime (int, int, int)
71             Assert.Equal(1900, CTest.Value.Year);
72             Assert.Equal(1, CTest.Value.Month);
73             Assert.Equal(1, CTest.Value.Day);
74             Assert.Equal(0, CTest.Value.Hour);
75 
76             // SqlDateTime (int, int, int, int, int, int)
77             CTest = new SqlDateTime(5000, 12, 31);
78             Assert.Equal(5000, CTest.Value.Year);
79             Assert.Equal(12, CTest.Value.Month);
80             Assert.Equal(31, CTest.Value.Day);
81 
82             // SqlDateTime (int, int, int, int, int, int, double)
83             CTest = new SqlDateTime(1978, 5, 19, 3, 34, 0);
84             Assert.Equal(1978, CTest.Value.Year);
85             Assert.Equal(5, CTest.Value.Month);
86             Assert.Equal(19, CTest.Value.Day);
87             Assert.Equal(3, CTest.Value.Hour);
88             Assert.Equal(34, CTest.Value.Minute);
89             Assert.Equal(0, CTest.Value.Second);
90 
91             try
92             {
93                 CTest = new SqlDateTime(10000, 12, 31);
94                 Assert.False(true);
95             }
96             catch (Exception e)
97             {
98                 Assert.Equal(typeof(SqlTypeException), e.GetType());
99             }
100 
101             // SqlDateTime (int, int, int, int, int, int, int)
102             CTest = new SqlDateTime(1978, 5, 19, 3, 34, 0, 12);
103             Assert.Equal(1978, CTest.Value.Year);
104             Assert.Equal(5, CTest.Value.Month);
105             Assert.Equal(19, CTest.Value.Day);
106             Assert.Equal(3, CTest.Value.Hour);
107             Assert.Equal(34, CTest.Value.Minute);
108             Assert.Equal(0, CTest.Value.Second);
109             Assert.Equal(0, CTest.Value.Millisecond);
110         }
111 
112         // Test public fields
113         [Fact]
PublicFields()114         public void PublicFields()
115         {
116             // MaxValue
117             Assert.Equal(9999, SqlDateTime.MaxValue.Value.Year);
118             Assert.Equal(12, SqlDateTime.MaxValue.Value.Month);
119             Assert.Equal(31, SqlDateTime.MaxValue.Value.Day);
120             Assert.Equal(23, SqlDateTime.MaxValue.Value.Hour);
121             Assert.Equal(59, SqlDateTime.MaxValue.Value.Minute);
122             Assert.Equal(59, SqlDateTime.MaxValue.Value.Second);
123 
124             // MinValue
125             Assert.Equal(1753, SqlDateTime.MinValue.Value.Year);
126             Assert.Equal(1, SqlDateTime.MinValue.Value.Month);
127             Assert.Equal(1, SqlDateTime.MinValue.Value.Day);
128             Assert.Equal(0, SqlDateTime.MinValue.Value.Hour);
129             Assert.Equal(0, SqlDateTime.MinValue.Value.Minute);
130             Assert.Equal(0, SqlDateTime.MinValue.Value.Second);
131 
132             // Null
133             Assert.True(SqlDateTime.Null.IsNull);
134 
135             // SQLTicksPerHour
136             Assert.Equal(1080000, SqlDateTime.SQLTicksPerHour);
137 
138             // SQLTicksPerMinute
139             Assert.Equal(18000, SqlDateTime.SQLTicksPerMinute);
140 
141             // SQLTicksPerSecond
142             Assert.Equal(300, SqlDateTime.SQLTicksPerSecond);
143         }
144 
145         // Test properties
146         [Fact]
Properties()147         public void Properties()
148         {
149             // DayTicks
150             Assert.Equal(37546, _test1.DayTicks);
151 
152             try
153             {
154                 int test = SqlDateTime.Null.DayTicks;
155                 Assert.False(true);
156             }
157             catch (Exception e)
158             {
159                 Assert.Equal(typeof(SqlNullValueException), e.GetType());
160             }
161 
162             // IsNull
163             Assert.True(SqlDateTime.Null.IsNull);
164             Assert.True(!_test2.IsNull);
165 
166             // TimeTicks
167             Assert.Equal(10440000, _test1.TimeTicks);
168 
169             try
170             {
171                 int test = SqlDateTime.Null.TimeTicks;
172                 Assert.False(true);
173             }
174             catch (Exception e)
175             {
176                 Assert.Equal(typeof(SqlNullValueException), e.GetType());
177             }
178 
179             // Value
180             Assert.Equal(2003, _test2.Value.Year);
181             Assert.Equal(2002, _test1.Value.Year);
182         }
183 
184         // PUBLIC METHODS
185 
186         [Fact]
CompareTo()187         public void CompareTo()
188         {
189             SqlString TestString = new SqlString("This is a test");
190 
191             Assert.True(_test1.CompareTo(_test3) < 0);
192             Assert.True(_test2.CompareTo(_test1) > 0);
193             Assert.True(_test2.CompareTo(_test3) == 0);
194             Assert.True(_test1.CompareTo(SqlDateTime.Null) > 0);
195 
196             try
197             {
198                 _test1.CompareTo(TestString);
199                 Assert.False(true);
200             }
201             catch (Exception e)
202             {
203                 Assert.Equal(typeof(ArgumentException), e.GetType());
204             }
205         }
206 
207         [Fact]
EqualsMethods()208         public void EqualsMethods()
209         {
210             Assert.True(!_test1.Equals(_test2));
211             Assert.True(!_test2.Equals(new SqlString("TEST")));
212             Assert.True(_test2.Equals(_test3));
213 
214             // Static Equals()-method
215             Assert.True(SqlDateTime.Equals(_test2, _test3).Value);
216             Assert.True(!SqlDateTime.Equals(_test1, _test2).Value);
217         }
218 
219         [Fact]
GetHashCodeTest()220         public void GetHashCodeTest()
221         {
222             // FIXME: Better way to test HashCode
223             Assert.Equal(_test1.GetHashCode(), _test1.GetHashCode());
224             Assert.True(_test2.GetHashCode() != _test1.GetHashCode());
225         }
226 
227         [Fact]
GetTypeTest()228         public void GetTypeTest()
229         {
230             Assert.Equal("System.Data.SqlTypes.SqlDateTime", _test1.GetType().ToString());
231             Assert.Equal("System.DateTime", _test1.Value.GetType().ToString());
232         }
233 
234         [Fact]
Greaters()235         public void Greaters()
236         {
237             // GreateThan ()
238             Assert.True(!SqlDateTime.GreaterThan(_test1, _test2).Value);
239             Assert.True(SqlDateTime.GreaterThan(_test2, _test1).Value);
240             Assert.True(!SqlDateTime.GreaterThan(_test2, _test3).Value);
241 
242             // GreaterTharOrEqual ()
243             Assert.True(!SqlDateTime.GreaterThanOrEqual(_test1, _test2).Value);
244             Assert.True(SqlDateTime.GreaterThanOrEqual(_test2, _test1).Value);
245             Assert.True(SqlDateTime.GreaterThanOrEqual(_test2, _test3).Value);
246         }
247 
248         [Fact]
Lessers()249         public void Lessers()
250         {
251             // LessThan()
252             Assert.True(!SqlDateTime.LessThan(_test2, _test3).Value);
253             Assert.True(!SqlDateTime.LessThan(_test2, _test1).Value);
254             Assert.True(SqlDateTime.LessThan(_test1, _test3).Value);
255 
256             // LessThanOrEqual ()
257             Assert.True(SqlDateTime.LessThanOrEqual(_test1, _test2).Value);
258             Assert.True(!SqlDateTime.LessThanOrEqual(_test2, _test1).Value);
259             Assert.True(SqlDateTime.LessThanOrEqual(_test3, _test2).Value);
260             Assert.True(SqlDateTime.LessThanOrEqual(_test1, SqlDateTime.Null).IsNull);
261         }
262 
263         [Fact]
NotEquals()264         public void NotEquals()
265         {
266             Assert.True(SqlDateTime.NotEquals(_test1, _test2).Value);
267             Assert.True(SqlDateTime.NotEquals(_test3, _test1).Value);
268             Assert.True(!SqlDateTime.NotEquals(_test2, _test3).Value);
269             Assert.True(SqlDateTime.NotEquals(SqlDateTime.Null, _test2).IsNull);
270         }
271 
272         [Fact]
Parse()273         public void Parse()
274         {
275             try
276             {
277                 SqlDateTime.Parse(null);
278                 Assert.False(true);
279             }
280             catch (Exception e)
281             {
282                 Assert.Equal(typeof(ArgumentNullException), e.GetType());
283             }
284 
285             try
286             {
287                 SqlDateTime.Parse("not-a-number");
288                 Assert.False(true);
289             }
290             catch (Exception e)
291             {
292                 Assert.Equal(typeof(FormatException), e.GetType());
293             }
294 
295             SqlDateTime t1 = SqlDateTime.Parse("02/25/2002");
296             Assert.Equal(_myTicks[0], t1.Value.Ticks);
297 
298             try
299             {
300                 t1 = SqlDateTime.Parse("2002-02-25");
301             }
302             catch (Exception e)
303             {
304                 Assert.False(true);
305             }
306 
307             // Thanks for Martin Baulig for these (DateTimeTest.cs)
308             Assert.Equal(_myTicks[0], t1.Value.Ticks);
309             t1 = SqlDateTime.Parse("Monday, 25 February 2002");
310             Assert.Equal(_myTicks[0], t1.Value.Ticks);
311             t1 = SqlDateTime.Parse("Monday, 25 February 2002 05:25");
312             Assert.Equal(_myTicks[3], t1.Value.Ticks);
313             t1 = SqlDateTime.Parse("Monday, 25 February 2002 05:25:13");
314             Assert.Equal(_myTicks[4], t1.Value.Ticks);
315             t1 = SqlDateTime.Parse("02/25/2002 05:25");
316             Assert.Equal(_myTicks[3], t1.Value.Ticks);
317             t1 = SqlDateTime.Parse("02/25/2002 05:25:13");
318             Assert.Equal(_myTicks[4], t1.Value.Ticks);
319             t1 = SqlDateTime.Parse("2002-02-25 04:25:13Z");
320             t1 = t1.Value.ToUniversalTime();
321             Assert.Equal(2002, t1.Value.Year);
322             Assert.Equal(02, t1.Value.Month);
323             Assert.Equal(25, t1.Value.Day);
324             Assert.Equal(04, t1.Value.Hour);
325             Assert.Equal(25, t1.Value.Minute);
326             Assert.Equal(13, t1.Value.Second);
327 
328             SqlDateTime t2 = new SqlDateTime(DateTime.Today.Year, 2, 25);
329             t1 = SqlDateTime.Parse("February 25");
330             Assert.Equal(t2.Value.Ticks, t1.Value.Ticks);
331 
332             t2 = new SqlDateTime(DateTime.Today.Year, 2, 8);
333             t1 = SqlDateTime.Parse("February 08");
334             Assert.Equal(t2.Value.Ticks, t1.Value.Ticks);
335 
336             t1 = SqlDateTime.Parse("Mon, 25 Feb 2002 04:25:13 GMT");
337             t1 = t1.Value.ToUniversalTime();
338             Assert.Equal(2002, t1.Value.Year);
339             Assert.Equal(02, t1.Value.Month);
340             Assert.Equal(25, t1.Value.Day);
341             Assert.Equal(04, t1.Value.Hour);
342             Assert.Equal(25, t1.Value.Minute);
343             Assert.Equal(13, t1.Value.Second);
344 
345             t1 = SqlDateTime.Parse("2002-02-25T05:25:13");
346             Assert.Equal(_myTicks[4], t1.Value.Ticks);
347 
348             t2 = DateTime.Today + new TimeSpan(5, 25, 0);
349             t1 = SqlDateTime.Parse("05:25");
350             Assert.Equal(t2.Value.Ticks, t1.Value.Ticks);
351 
352             t2 = DateTime.Today + new TimeSpan(5, 25, 13);
353             t1 = SqlDateTime.Parse("05:25:13");
354             Assert.Equal(t2.Value.Ticks, t1.Value.Ticks);
355 
356             t2 = new SqlDateTime(2002, 2, 1);
357             t1 = SqlDateTime.Parse("2002 February");
358             Assert.Equal(t2.Value.Ticks, t1.Value.Ticks);
359 
360             t2 = new SqlDateTime(2002, 2, 1);
361             t1 = SqlDateTime.Parse("2002 February");
362             Assert.Equal(t2.Value.Ticks, t1.Value.Ticks);
363 
364             t2 = new SqlDateTime(DateTime.Today.Year, 2, 8);
365             t1 = SqlDateTime.Parse("February 8");
366 
367             Assert.Equal(t2.Value.Ticks, t1.Value.Ticks);
368         }
369 
370         // OPERATORS
371         [Fact]
ArithmeticOperators()372         public void ArithmeticOperators()
373         {
374             TimeSpan TestSpan = new TimeSpan(20, 1, 20, 20);
375             SqlDateTime ResultDateTime;
376 
377             // "+"-operator
378             ResultDateTime = _test1 + TestSpan;
379             Assert.Equal(2002, ResultDateTime.Value.Year);
380             Assert.Equal(8, ResultDateTime.Value.Day);
381             Assert.Equal(11, ResultDateTime.Value.Hour);
382             Assert.Equal(0, ResultDateTime.Value.Minute);
383             Assert.Equal(20, ResultDateTime.Value.Second);
384             Assert.True((SqlDateTime.Null + TestSpan).IsNull);
385 
386             try
387             {
388                 ResultDateTime = SqlDateTime.MaxValue + TestSpan;
389                 Assert.False(true);
390             }
391             catch (Exception e)
392             {
393                 Assert.Equal(typeof(ArgumentOutOfRangeException), e.GetType());
394             }
395 
396             // "-"-operator
397             ResultDateTime = _test1 - TestSpan;
398             Assert.Equal(2002, ResultDateTime.Value.Year);
399             Assert.Equal(29, ResultDateTime.Value.Day);
400             Assert.Equal(8, ResultDateTime.Value.Hour);
401             Assert.Equal(19, ResultDateTime.Value.Minute);
402             Assert.Equal(40, ResultDateTime.Value.Second);
403             Assert.True((SqlDateTime.Null - TestSpan).IsNull);
404 
405             try
406             {
407                 ResultDateTime = SqlDateTime.MinValue - TestSpan;
408                 Assert.False(true);
409             }
410             catch (Exception e)
411             {
412                 Assert.Equal(typeof(SqlTypeException), e.GetType());
413             }
414         }
415 
416         [Fact]
ThanOrEqualOperators()417         public void ThanOrEqualOperators()
418         {
419             // == -operator
420             Assert.True((_test2 == _test3).Value);
421             Assert.True(!(_test1 == _test2).Value);
422             Assert.True((_test1 == SqlDateTime.Null).IsNull);
423 
424             // != -operator
425             Assert.True(!(_test2 != _test3).Value);
426             Assert.True((_test1 != _test3).Value);
427             Assert.True((_test1 != SqlDateTime.Null).IsNull);
428 
429             // > -operator
430             Assert.True((_test2 > _test1).Value);
431             Assert.True(!(_test3 > _test2).Value);
432             Assert.True((_test1 > SqlDateTime.Null).IsNull);
433 
434             // >=  -operator
435             Assert.True(!(_test1 >= _test3).Value);
436             Assert.True((_test3 >= _test1).Value);
437             Assert.True((_test2 >= _test3).Value);
438             Assert.True((_test1 >= SqlDateTime.Null).IsNull);
439 
440             // < -operator
441             Assert.True(!(_test2 < _test1).Value);
442             Assert.True((_test1 < _test3).Value);
443             Assert.True(!(_test2 < _test3).Value);
444             Assert.True((_test1 < SqlDateTime.Null).IsNull);
445 
446             // <= -operator
447             Assert.True((_test1 <= _test3).Value);
448             Assert.True(!(_test3 <= _test1).Value);
449             Assert.True((_test2 <= _test3).Value);
450             Assert.True((_test1 <= SqlDateTime.Null).IsNull);
451         }
452 
453         [Fact]
SqlDateTimeToDateTime()454         public void SqlDateTimeToDateTime()
455         {
456             Assert.Equal(2002, ((DateTime)_test1).Year);
457             Assert.Equal(2003, ((DateTime)_test2).Year);
458             Assert.Equal(10, ((DateTime)_test1).Month);
459             Assert.Equal(19, ((DateTime)_test1).Day);
460             Assert.Equal(9, ((DateTime)_test1).Hour);
461             Assert.Equal(40, ((DateTime)_test1).Minute);
462             Assert.Equal(0, ((DateTime)_test1).Second);
463         }
464 
465         [Fact]
SqlStringToSqlDateTime()466         public void SqlStringToSqlDateTime()
467         {
468             SqlString TestString = new SqlString("02/25/2002");
469             SqlDateTime t1 = (SqlDateTime)TestString;
470 
471             Assert.Equal(_myTicks[0], t1.Value.Ticks);
472 
473             // Thanks for Martin Baulig for these (DateTimeTest.cs)
474             Assert.Equal(_myTicks[0], t1.Value.Ticks);
475             t1 = (SqlDateTime)new SqlString("Monday, 25 February 2002");
476             Assert.Equal(_myTicks[0], t1.Value.Ticks);
477             t1 = (SqlDateTime)new SqlString("Monday, 25 February 2002 05:25");
478             Assert.Equal(_myTicks[3], t1.Value.Ticks);
479             t1 = (SqlDateTime)new SqlString("Monday, 25 February 2002 05:25:13");
480             Assert.Equal(_myTicks[4], t1.Value.Ticks);
481             t1 = (SqlDateTime)new SqlString("02/25/2002 05:25");
482             Assert.Equal(_myTicks[3], t1.Value.Ticks);
483             t1 = (SqlDateTime)new SqlString("02/25/2002 05:25:13");
484             Assert.Equal(_myTicks[4], t1.Value.Ticks);
485             t1 = (SqlDateTime)new SqlString("2002-02-25 04:25:13Z");
486             t1 = t1.Value.ToUniversalTime();
487             Assert.Equal(2002, t1.Value.Year);
488             Assert.Equal(02, t1.Value.Month);
489             Assert.Equal(25, t1.Value.Day);
490             Assert.Equal(04, t1.Value.Hour);
491             Assert.Equal(25, t1.Value.Minute);
492             Assert.Equal(13, t1.Value.Second);
493 
494             SqlDateTime t2 = new SqlDateTime(DateTime.Today.Year, 2, 25);
495             t1 = (SqlDateTime)new SqlString("February 25");
496             Assert.Equal(t2.Value.Ticks, t1.Value.Ticks);
497 
498             t2 = new SqlDateTime(DateTime.Today.Year, 2, 8);
499             t1 = (SqlDateTime)new SqlString("February 08");
500             Assert.Equal(t2.Value.Ticks, t1.Value.Ticks);
501 
502             t1 = (SqlDateTime)new SqlString("Mon, 25 Feb 2002 04:25:13 GMT");
503             t1 = t1.Value.ToUniversalTime();
504             Assert.Equal(2002, t1.Value.Year);
505             Assert.Equal(02, t1.Value.Month);
506             Assert.Equal(25, t1.Value.Day);
507             Assert.Equal(04, t1.Value.Hour);
508             Assert.Equal(25, t1.Value.Minute);
509             Assert.Equal(13, t1.Value.Second);
510 
511             t1 = (SqlDateTime)new SqlString("2002-02-25T05:25:13");
512             Assert.Equal(_myTicks[4], t1.Value.Ticks);
513 
514             t2 = DateTime.Today + new TimeSpan(5, 25, 0);
515             t1 = (SqlDateTime)new SqlString("05:25");
516             Assert.Equal(t2.Value.Ticks, t1.Value.Ticks);
517 
518             t2 = DateTime.Today + new TimeSpan(5, 25, 13);
519             t1 = (SqlDateTime)new SqlString("05:25:13");
520             Assert.Equal(t2.Value.Ticks, t1.Value.Ticks);
521 
522             t2 = new SqlDateTime(2002, 2, 1);
523             t1 = (SqlDateTime)new SqlString("2002 February");
524             Assert.Equal(t2.Value.Ticks, t1.Value.Ticks);
525 
526             t2 = new SqlDateTime(2002, 2, 1);
527             t1 = (SqlDateTime)new SqlString("2002 February");
528             Assert.Equal(t2.Value.Ticks, t1.Value.Ticks);
529 
530             t2 = new SqlDateTime(DateTime.Today.Year, 2, 8);
531             t1 = (SqlDateTime)new SqlString("February 8");
532 
533             Assert.Equal(t2.Value.Ticks, t1.Value.Ticks);
534         }
535 
536         [Fact]
DateTimeToSqlDateTime()537         public void DateTimeToSqlDateTime()
538         {
539             DateTime DateTimeTest = new DateTime(2002, 10, 19, 11, 53, 4);
540             SqlDateTime Result = DateTimeTest;
541             Assert.Equal(2002, Result.Value.Year);
542             Assert.Equal(10, Result.Value.Month);
543             Assert.Equal(19, Result.Value.Day);
544             Assert.Equal(11, Result.Value.Hour);
545             Assert.Equal(53, Result.Value.Minute);
546             Assert.Equal(4, Result.Value.Second);
547         }
548 
549         [Fact]
TicksRoundTrip()550         public void TicksRoundTrip()
551         {
552             SqlDateTime d1 = new SqlDateTime(2007, 05, 04, 18, 02, 40, 398.25);
553             SqlDateTime d2 = new SqlDateTime(d1.DayTicks, d1.TimeTicks);
554 
555             Assert.Equal(39204, d1.DayTicks);
556             Assert.Equal(19488119, d1.TimeTicks);
557             Assert.Equal(633138985603970000, d1.Value.Ticks);
558             Assert.Equal(d1.DayTicks, d2.DayTicks);
559             Assert.Equal(d1.TimeTicks, d2.TimeTicks);
560             Assert.Equal(d1.Value.Ticks, d2.Value.Ticks);
561             Assert.Equal(d1, d2);
562         }
563 
564         [Fact]
EffingBilisecond()565         public void EffingBilisecond()
566         {
567             SqlDateTime d1 = new SqlDateTime(2007, 05, 04, 18, 02, 40, 398252);
568 
569             Assert.Equal(39204, d1.DayTicks);
570             Assert.Equal(19488119, d1.TimeTicks);
571             Assert.Equal(633138985603970000, d1.Value.Ticks);
572         }
573 
574         [Fact]
GetXsdTypeTest()575         public void GetXsdTypeTest()
576         {
577             XmlQualifiedName qualifiedName = SqlDateTime.GetXsdType(null);
578             Assert.Equal("dateTime", qualifiedName.Name);
579         }
580     }
581 }
582 
583