Add tests for time-related extension methods

X10D.Tests/src/Time/ByteTests.cs

@@ -0,0 +1,32 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using X10D.Time;
+
+namespace X10D.Tests.Time;
+
+[TestClass]
+public class ByteTests
+{
+    [TestMethod]
+    public void Zero_Should_Be_Zero_TimeSpan()
+    {
+        Assert.AreEqual(TimeSpan.Zero, ((byte)0).Ticks());
+        Assert.AreEqual(TimeSpan.Zero, ((byte)0).Milliseconds());
+        Assert.AreEqual(TimeSpan.Zero, ((byte)0).Seconds());
+        Assert.AreEqual(TimeSpan.Zero, ((byte)0).Minutes());
+        Assert.AreEqual(TimeSpan.Zero, ((byte)0).Days());
+        Assert.AreEqual(TimeSpan.Zero, ((byte)0).Hours());
+        Assert.AreEqual(TimeSpan.Zero, ((byte)0).Weeks());
+    }
+
+    [TestMethod]
+    public void One_Should_Be_Positive()
+    {
+        Assert.IsTrue(((byte)1).Ticks() > TimeSpan.Zero);
+        Assert.IsTrue(((byte)1).Milliseconds() > TimeSpan.Zero);
+        Assert.IsTrue(((byte)1).Seconds() > TimeSpan.Zero);
+        Assert.IsTrue(((byte)1).Minutes() > TimeSpan.Zero);
+        Assert.IsTrue(((byte)1).Days() > TimeSpan.Zero);
+        Assert.IsTrue(((byte)1).Hours() > TimeSpan.Zero);
+        Assert.IsTrue(((byte)1).Weeks() > TimeSpan.Zero);
+    }
+}

X10D.Tests/src/Time/DecimalTests.cs

@@ -0,0 +1,41 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using X10D.Time;
+
+namespace X10D.Tests.Time;
+
+[TestClass]
+public class DecimalTests
+{
+    [TestMethod]
+    public void Zero_Should_Be_Zero_TimeSpan()
+    {
+        Assert.AreEqual(TimeSpan.Zero, 0m.Milliseconds());
+        Assert.AreEqual(TimeSpan.Zero, 0m.Seconds());
+        Assert.AreEqual(TimeSpan.Zero, 0m.Minutes());
+        Assert.AreEqual(TimeSpan.Zero, 0m.Days());
+        Assert.AreEqual(TimeSpan.Zero, 0m.Hours());
+        Assert.AreEqual(TimeSpan.Zero, 0m.Weeks());
+    }
+
+    [TestMethod]
+    public void One_Should_Be_Positive()
+    {
+        Assert.IsTrue(1m.Milliseconds() > TimeSpan.Zero);
+        Assert.IsTrue(1m.Seconds() > TimeSpan.Zero);
+        Assert.IsTrue(1m.Minutes() > TimeSpan.Zero);
+        Assert.IsTrue(1m.Days() > TimeSpan.Zero);
+        Assert.IsTrue(1m.Hours() > TimeSpan.Zero);
+        Assert.IsTrue(1m.Weeks() > TimeSpan.Zero);
+    }
+
+    [TestMethod]
+    public void MinusOne_Should_Be_Negative()
+    {
+        Assert.IsTrue((-1m).Milliseconds() < TimeSpan.Zero);
+        Assert.IsTrue((-1m).Seconds() < TimeSpan.Zero);
+        Assert.IsTrue((-1m).Minutes() < TimeSpan.Zero);
+        Assert.IsTrue((-1m).Days() < TimeSpan.Zero);
+        Assert.IsTrue((-1m).Hours() < TimeSpan.Zero);
+        Assert.IsTrue((-1m).Weeks() < TimeSpan.Zero);
+    }
+}

X10D.Tests/src/Time/DoubleTests.cs

@@ -0,0 +1,53 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using X10D.Time;
+
+namespace X10D.Tests.Time;
+
+[TestClass]
+public class DoubleTests
+{
+    private Half _negativeOne;
+    private Half _one;
+    private Half _zero;
+
+    [TestInitialize]
+    public void Initialize()
+    {
+        _negativeOne = (Half)(-1);
+        _one = (Half)1;
+        _zero = (Half)0;
+    }
+
+    [TestMethod]
+    public void Zero_Should_Be_Zero_TimeSpan()
+    {
+        Assert.AreEqual(TimeSpan.Zero, _zero.Milliseconds());
+        Assert.AreEqual(TimeSpan.Zero, _zero.Seconds());
+        Assert.AreEqual(TimeSpan.Zero, _zero.Minutes());
+        Assert.AreEqual(TimeSpan.Zero, _zero.Days());
+        Assert.AreEqual(TimeSpan.Zero, _zero.Hours());
+        Assert.AreEqual(TimeSpan.Zero, _zero.Weeks());
+    }
+
+    [TestMethod]
+    public void One_Should_Be_Positive()
+    {
+        Assert.IsTrue(_one.Milliseconds() > TimeSpan.Zero);
+        Assert.IsTrue(_one.Seconds() > TimeSpan.Zero);
+        Assert.IsTrue(_one.Minutes() > TimeSpan.Zero);
+        Assert.IsTrue(_one.Days() > TimeSpan.Zero);
+        Assert.IsTrue(_one.Hours() > TimeSpan.Zero);
+        Assert.IsTrue(_one.Weeks() > TimeSpan.Zero);
+    }
+
+    [TestMethod]
+    public void MinusOne_Should_Be_Negative()
+    {
+        Assert.IsTrue((_negativeOne).Milliseconds() < TimeSpan.Zero);
+        Assert.IsTrue((_negativeOne).Seconds() < TimeSpan.Zero);
+        Assert.IsTrue((_negativeOne).Minutes() < TimeSpan.Zero);
+        Assert.IsTrue((_negativeOne).Days() < TimeSpan.Zero);
+        Assert.IsTrue((_negativeOne).Hours() < TimeSpan.Zero);
+        Assert.IsTrue((_negativeOne).Weeks() < TimeSpan.Zero);
+    }
+}

X10D.Tests/src/Time/HalfTests.cs

@@ -0,0 +1,41 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using X10D.Time;
+
+namespace X10D.Tests.Time;
+
+[TestClass]
+public class HalfTests
+{
+    [TestMethod]
+    public void Zero_Should_Be_Zero_TimeSpan()
+    {
+        Assert.AreEqual(TimeSpan.Zero, 0.0.Milliseconds());
+        Assert.AreEqual(TimeSpan.Zero, 0.0.Seconds());
+        Assert.AreEqual(TimeSpan.Zero, 0.0.Minutes());
+        Assert.AreEqual(TimeSpan.Zero, 0.0.Days());
+        Assert.AreEqual(TimeSpan.Zero, 0.0.Hours());
+        Assert.AreEqual(TimeSpan.Zero, 0.0.Weeks());
+    }
+
+    [TestMethod]
+    public void One_Should_Be_Positive()
+    {
+        Assert.IsTrue(1.0.Milliseconds() > TimeSpan.Zero);
+        Assert.IsTrue(1.0.Seconds() > TimeSpan.Zero);
+        Assert.IsTrue(1.0.Minutes() > TimeSpan.Zero);
+        Assert.IsTrue(1.0.Days() > TimeSpan.Zero);
+        Assert.IsTrue(1.0.Hours() > TimeSpan.Zero);
+        Assert.IsTrue(1.0.Weeks() > TimeSpan.Zero);
+    }
+
+    [TestMethod]
+    public void MinusOne_Should_Be_Negative()
+    {
+        Assert.IsTrue((-1.0).Milliseconds() < TimeSpan.Zero);
+        Assert.IsTrue((-1.0).Seconds() < TimeSpan.Zero);
+        Assert.IsTrue((-1.0).Minutes() < TimeSpan.Zero);
+        Assert.IsTrue((-1.0).Days() < TimeSpan.Zero);
+        Assert.IsTrue((-1.0).Hours() < TimeSpan.Zero);
+        Assert.IsTrue((-1.0).Weeks() < TimeSpan.Zero);
+    }
+}

X10D.Tests/src/Time/Int16Tests.cs

@@ -0,0 +1,44 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using X10D.Time;
+
+namespace X10D.Tests.Time;
+
+[TestClass]
+public class Int16Tests
+{
+    [TestMethod]
+    public void Zero_Should_Be_Zero_TimeSpan()
+    {
+        Assert.AreEqual(TimeSpan.Zero, ((short)0).Ticks());
+        Assert.AreEqual(TimeSpan.Zero, ((short)0).Milliseconds());
+        Assert.AreEqual(TimeSpan.Zero, ((short)0).Seconds());
+        Assert.AreEqual(TimeSpan.Zero, ((short)0).Minutes());
+        Assert.AreEqual(TimeSpan.Zero, ((short)0).Days());
+        Assert.AreEqual(TimeSpan.Zero, ((short)0).Hours());
+        Assert.AreEqual(TimeSpan.Zero, ((short)0).Weeks());
+    }
+
+    [TestMethod]
+    public void One_Should_Be_Positive()
+    {
+        Assert.IsTrue(((short)1).Ticks() > TimeSpan.Zero);
+        Assert.IsTrue(((short)1).Milliseconds() > TimeSpan.Zero);
+        Assert.IsTrue(((short)1).Seconds() > TimeSpan.Zero);
+        Assert.IsTrue(((short)1).Minutes() > TimeSpan.Zero);
+        Assert.IsTrue(((short)1).Days() > TimeSpan.Zero);
+        Assert.IsTrue(((short)1).Hours() > TimeSpan.Zero);
+        Assert.IsTrue(((short)1).Weeks() > TimeSpan.Zero);
+    }
+
+    [TestMethod]
+    public void MinusOne_Should_Be_Negative()
+    {
+        Assert.IsTrue(((short)-1).Ticks() < TimeSpan.Zero);
+        Assert.IsTrue(((short)-1).Milliseconds() < TimeSpan.Zero);
+        Assert.IsTrue(((short)-1).Seconds() < TimeSpan.Zero);
+        Assert.IsTrue(((short)-1).Minutes() < TimeSpan.Zero);
+        Assert.IsTrue(((short)-1).Days() < TimeSpan.Zero);
+        Assert.IsTrue(((short)-1).Hours() < TimeSpan.Zero);
+        Assert.IsTrue(((short)-1).Weeks() < TimeSpan.Zero);
+    }
+}

X10D.Tests/src/Time/Int32Tests.cs

@@ -0,0 +1,44 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using X10D.Time;
+
+namespace X10D.Tests.Time;
+
+[TestClass]
+public class Int32Tests
+{
+    [TestMethod]
+    public void Zero_Should_Be_Zero_TimeSpan()
+    {
+        Assert.AreEqual(TimeSpan.Zero, 0.Ticks());
+        Assert.AreEqual(TimeSpan.Zero, 0.Milliseconds());
+        Assert.AreEqual(TimeSpan.Zero, 0.Seconds());
+        Assert.AreEqual(TimeSpan.Zero, 0.Minutes());
+        Assert.AreEqual(TimeSpan.Zero, 0.Days());
+        Assert.AreEqual(TimeSpan.Zero, 0.Hours());
+        Assert.AreEqual(TimeSpan.Zero, 0.Weeks());
+    }
+
+    [TestMethod]
+    public void One_Should_Be_Positive()
+    {
+        Assert.IsTrue(1.Ticks() > TimeSpan.Zero);
+        Assert.IsTrue(1.Milliseconds() > TimeSpan.Zero);
+        Assert.IsTrue(1.Seconds() > TimeSpan.Zero);
+        Assert.IsTrue(1.Minutes() > TimeSpan.Zero);
+        Assert.IsTrue(1.Days() > TimeSpan.Zero);
+        Assert.IsTrue(1.Hours() > TimeSpan.Zero);
+        Assert.IsTrue(1.Weeks() > TimeSpan.Zero);
+    }
+
+    [TestMethod]
+    public void MinusOne_Should_Be_Negative()
+    {
+        Assert.IsTrue((-1).Ticks() < TimeSpan.Zero);
+        Assert.IsTrue((-1).Milliseconds() < TimeSpan.Zero);
+        Assert.IsTrue((-1).Seconds() < TimeSpan.Zero);
+        Assert.IsTrue((-1).Minutes() < TimeSpan.Zero);
+        Assert.IsTrue((-1).Days() < TimeSpan.Zero);
+        Assert.IsTrue((-1).Hours() < TimeSpan.Zero);
+        Assert.IsTrue((-1).Weeks() < TimeSpan.Zero);
+    }
+}

X10D.Tests/src/Time/Int64Tests.cs

@@ -0,0 +1,44 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using X10D.Time;
+
+namespace X10D.Tests.Time;
+
+[TestClass]
+public class Int64Tests
+{
+    [TestMethod]
+    public void Zero_Should_Be_Zero_TimeSpan()
+    {
+        Assert.AreEqual(TimeSpan.Zero, 0L.Ticks());
+        Assert.AreEqual(TimeSpan.Zero, 0L.Milliseconds());
+        Assert.AreEqual(TimeSpan.Zero, 0L.Seconds());
+        Assert.AreEqual(TimeSpan.Zero, 0L.Minutes());
+        Assert.AreEqual(TimeSpan.Zero, 0L.Days());
+        Assert.AreEqual(TimeSpan.Zero, 0L.Hours());
+        Assert.AreEqual(TimeSpan.Zero, 0L.Weeks());
+    }
+
+    [TestMethod]
+    public void One_Should_Be_Positive()
+    {
+        Assert.IsTrue(1L.Ticks() > TimeSpan.Zero);
+        Assert.IsTrue(1L.Milliseconds() > TimeSpan.Zero);
+        Assert.IsTrue(1L.Seconds() > TimeSpan.Zero);
+        Assert.IsTrue(1L.Minutes() > TimeSpan.Zero);
+        Assert.IsTrue(1L.Days() > TimeSpan.Zero);
+        Assert.IsTrue(1L.Hours() > TimeSpan.Zero);
+        Assert.IsTrue(1L.Weeks() > TimeSpan.Zero);
+    }
+
+    [TestMethod]
+    public void MinusOne_Should_Be_Negative()
+    {
+        Assert.IsTrue((-1L).Ticks() < TimeSpan.Zero);
+        Assert.IsTrue((-1L).Milliseconds() < TimeSpan.Zero);
+        Assert.IsTrue((-1L).Seconds() < TimeSpan.Zero);
+        Assert.IsTrue((-1L).Minutes() < TimeSpan.Zero);
+        Assert.IsTrue((-1L).Days() < TimeSpan.Zero);
+        Assert.IsTrue((-1L).Hours() < TimeSpan.Zero);
+        Assert.IsTrue((-1L).Weeks() < TimeSpan.Zero);
+    }
+}

X10D.Tests/src/Time/SByteTests.cs

@@ -0,0 +1,45 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using X10D.Time;
+
+namespace X10D.Tests.Time;
+
+[TestClass]
+[CLSCompliant(false)]
+public class SByteTests
+{
+    [TestMethod]
+    public void Zero_Should_Be_Zero_TimeSpan()
+    {
+        Assert.AreEqual(TimeSpan.Zero, ((sbyte)0).Ticks());
+        Assert.AreEqual(TimeSpan.Zero, ((sbyte)0).Milliseconds());
+        Assert.AreEqual(TimeSpan.Zero, ((sbyte)0).Seconds());
+        Assert.AreEqual(TimeSpan.Zero, ((sbyte)0).Minutes());
+        Assert.AreEqual(TimeSpan.Zero, ((sbyte)0).Days());
+        Assert.AreEqual(TimeSpan.Zero, ((sbyte)0).Hours());
+        Assert.AreEqual(TimeSpan.Zero, ((sbyte)0).Weeks());
+    }
+
+    [TestMethod]
+    public void One_Should_Be_Positive()
+    {
+        Assert.IsTrue(((sbyte)1).Ticks() > TimeSpan.Zero);
+        Assert.IsTrue(((sbyte)1).Milliseconds() > TimeSpan.Zero);
+        Assert.IsTrue(((sbyte)1).Seconds() > TimeSpan.Zero);
+        Assert.IsTrue(((sbyte)1).Minutes() > TimeSpan.Zero);
+        Assert.IsTrue(((sbyte)1).Days() > TimeSpan.Zero);
+        Assert.IsTrue(((sbyte)1).Hours() > TimeSpan.Zero);
+        Assert.IsTrue(((sbyte)1).Weeks() > TimeSpan.Zero);
+    }
+
+    [TestMethod]
+    public void MinusOne_Should_Be_Negative()
+    {
+        Assert.IsTrue(((sbyte)-1).Ticks() < TimeSpan.Zero);
+        Assert.IsTrue(((sbyte)-1).Milliseconds() < TimeSpan.Zero);
+        Assert.IsTrue(((sbyte)-1).Seconds() < TimeSpan.Zero);
+        Assert.IsTrue(((sbyte)-1).Minutes() < TimeSpan.Zero);
+        Assert.IsTrue(((sbyte)-1).Days() < TimeSpan.Zero);
+        Assert.IsTrue(((sbyte)-1).Hours() < TimeSpan.Zero);
+        Assert.IsTrue(((sbyte)-1).Weeks() < TimeSpan.Zero);
+    }
+}

X10D.Tests/src/Time/SingleTests.cs

@@ -0,0 +1,41 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using X10D.Time;
+
+namespace X10D.Tests.Time;
+
+[TestClass]
+public class SingleTests
+{
+    [TestMethod]
+    public void Zero_Should_Be_Zero_TimeSpan()
+    {
+        Assert.AreEqual(TimeSpan.Zero, 0f.Milliseconds());
+        Assert.AreEqual(TimeSpan.Zero, 0f.Seconds());
+        Assert.AreEqual(TimeSpan.Zero, 0f.Minutes());
+        Assert.AreEqual(TimeSpan.Zero, 0f.Days());
+        Assert.AreEqual(TimeSpan.Zero, 0f.Hours());
+        Assert.AreEqual(TimeSpan.Zero, 0f.Weeks());
+    }
+
+    [TestMethod]
+    public void One_Should_Be_Positive()
+    {
+        Assert.IsTrue(1f.Milliseconds() > TimeSpan.Zero);
+        Assert.IsTrue(1f.Seconds() > TimeSpan.Zero);
+        Assert.IsTrue(1f.Minutes() > TimeSpan.Zero);
+        Assert.IsTrue(1f.Days() > TimeSpan.Zero);
+        Assert.IsTrue(1f.Hours() > TimeSpan.Zero);
+        Assert.IsTrue(1f.Weeks() > TimeSpan.Zero);
+    }
+
+    [TestMethod]
+    public void MinusOne_Should_Be_Negative()
+    {
+        Assert.IsTrue((-1f).Milliseconds() < TimeSpan.Zero);
+        Assert.IsTrue((-1f).Seconds() < TimeSpan.Zero);
+        Assert.IsTrue((-1f).Minutes() < TimeSpan.Zero);
+        Assert.IsTrue((-1f).Days() < TimeSpan.Zero);
+        Assert.IsTrue((-1f).Hours() < TimeSpan.Zero);
+        Assert.IsTrue((-1f).Weeks() < TimeSpan.Zero);
+    }
+}

X10D.Tests/src/Time/TimeSpanTests.cs

@@ -0,0 +1,42 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using X10D.Time;
+
+namespace X10D.Tests.Time;
+
+[TestClass]
+public class TimeSpanTests
+{
+    private TimeSpan _timeSpan;
+
+    [TestInitialize]
+    public void Initialize()
+    {
+        _timeSpan = new TimeSpan(1, 2, 3, 4, 5);
+    }
+
+    [TestMethod]
+    public void Ago_Should_Be_In_The_Past()
+    {
+        Assert.IsTrue(_timeSpan.Ago() < DateTime.Now);
+    }
+
+    [TestMethod]
+    public void FromNow_Should_Be_In_The_Past()
+    {
+        Assert.IsTrue(_timeSpan.FromNow() > DateTime.Now);
+    }
+
+    [TestMethod]
+    public void One_Day_Ago_Should_Be_Yesterday()
+    {
+        DateTime yesterday = DateTime.Now.AddDays(-1);
+        Assert.AreEqual(yesterday.Date, 1.Days().Ago().Date);
+    }
+
+    [TestMethod]
+    public void One_Day_FromNow_Should_Be_Tomorrow()
+    {
+        DateTime tomorrow = DateTime.Now.AddDays(1);
+        Assert.AreEqual(tomorrow.Date, 1.Days().FromNow().Date);
+    }
+}

X10D.Tests/src/Time/UInt16Tests.cs

@@ -0,0 +1,33 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using X10D.Time;
+
+namespace X10D.Tests.Time;
+
+[TestClass]
+[CLSCompliant(false)]
+public class UInt16Tests
+{
+    [TestMethod]
+    public void Zero_Should_Be_Zero_TimeSpan()
+    {
+        Assert.AreEqual(TimeSpan.Zero, ((ushort)0).Ticks());
+        Assert.AreEqual(TimeSpan.Zero, ((ushort)0).Milliseconds());
+        Assert.AreEqual(TimeSpan.Zero, ((ushort)0).Seconds());
+        Assert.AreEqual(TimeSpan.Zero, ((ushort)0).Minutes());
+        Assert.AreEqual(TimeSpan.Zero, ((ushort)0).Days());
+        Assert.AreEqual(TimeSpan.Zero, ((ushort)0).Hours());
+        Assert.AreEqual(TimeSpan.Zero, ((ushort)0).Weeks());
+    }
+
+    [TestMethod]
+    public void One_Should_Be_Positive()
+    {
+        Assert.IsTrue(((ushort)1).Ticks() > TimeSpan.Zero);
+        Assert.IsTrue(((ushort)1).Milliseconds() > TimeSpan.Zero);
+        Assert.IsTrue(((ushort)1).Seconds() > TimeSpan.Zero);
+        Assert.IsTrue(((ushort)1).Minutes() > TimeSpan.Zero);
+        Assert.IsTrue(((ushort)1).Days() > TimeSpan.Zero);
+        Assert.IsTrue(((ushort)1).Hours() > TimeSpan.Zero);
+        Assert.IsTrue(((ushort)1).Weeks() > TimeSpan.Zero);
+    }
+}

X10D.Tests/src/Time/UInt32Tests.cs

@@ -0,0 +1,33 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using X10D.Time;
+
+namespace X10D.Tests.Time;
+
+[TestClass]
+[CLSCompliant(false)]
+public class UInt32Tests
+{
+    [TestMethod]
+    public void Zero_Should_Be_Zero_TimeSpan()
+    {
+        Assert.AreEqual(TimeSpan.Zero, 0U.Ticks());
+        Assert.AreEqual(TimeSpan.Zero, 0U.Milliseconds());
+        Assert.AreEqual(TimeSpan.Zero, 0U.Seconds());
+        Assert.AreEqual(TimeSpan.Zero, 0U.Minutes());
+        Assert.AreEqual(TimeSpan.Zero, 0U.Days());
+        Assert.AreEqual(TimeSpan.Zero, 0U.Hours());
+        Assert.AreEqual(TimeSpan.Zero, 0U.Weeks());
+    }
+
+    [TestMethod]
+    public void One_Should_Be_Positive()
+    {
+        Assert.IsTrue(1U.Ticks() > TimeSpan.Zero);
+        Assert.IsTrue(1U.Milliseconds() > TimeSpan.Zero);
+        Assert.IsTrue(1U.Seconds() > TimeSpan.Zero);
+        Assert.IsTrue(1U.Minutes() > TimeSpan.Zero);
+        Assert.IsTrue(1U.Days() > TimeSpan.Zero);
+        Assert.IsTrue(1U.Hours() > TimeSpan.Zero);
+        Assert.IsTrue(1U.Weeks() > TimeSpan.Zero);
+    }
+}

X10D.Tests/src/Time/UInt64Tests.cs

@@ -0,0 +1,33 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using X10D.Time;
+
+namespace X10D.Tests.Time;
+
+[TestClass]
+[CLSCompliant(false)]
+public class UInt64Tests
+{
+    [TestMethod]
+    public void Zero_Should_Be_Zero_TimeSpan()
+    {
+        Assert.AreEqual(TimeSpan.Zero, 0UL.Ticks());
+        Assert.AreEqual(TimeSpan.Zero, 0UL.Milliseconds());
+        Assert.AreEqual(TimeSpan.Zero, 0UL.Seconds());
+        Assert.AreEqual(TimeSpan.Zero, 0UL.Minutes());
+        Assert.AreEqual(TimeSpan.Zero, 0UL.Days());
+        Assert.AreEqual(TimeSpan.Zero, 0UL.Hours());
+        Assert.AreEqual(TimeSpan.Zero, 0UL.Weeks());
+    }
+
+    [TestMethod]
+    public void One_Should_Be_Positive()
+    {
+        Assert.IsTrue(1UL.Ticks() > TimeSpan.Zero);
+        Assert.IsTrue(1UL.Milliseconds() > TimeSpan.Zero);
+        Assert.IsTrue(1UL.Seconds() > TimeSpan.Zero);
+        Assert.IsTrue(1UL.Minutes() > TimeSpan.Zero);
+        Assert.IsTrue(1UL.Days() > TimeSpan.Zero);
+        Assert.IsTrue(1UL.Hours() > TimeSpan.Zero);
+        Assert.IsTrue(1UL.Weeks() > TimeSpan.Zero);
+    }
+}