public void OffsetDateTimeProvider_TooLargeNegativeOffset_ConstructorThrowsException()
 {
     /* Create the test subject */
     TimeSpan         maximumAllowedOffset = DateTime.Now - DateTime.MinValue;
     TimeSpan         offset      = new TimeSpan((maximumAllowedOffset.Ticks * -1) - 2500);
     DateTimeProvider testSubject = new OffsetDateTimeProvider(offset);
 }
        public void OffsetDateTimeProvider_MinValueReturnsActualMinValue()
        {
            /* Create the test subject */
            DateTimeProvider testSubject = new OffsetDateTimeProvider(new TimeSpan(2, 35, 42));

            Assert.AreEqual(DateTime.MinValue, testSubject.MinValue);
        }
        public void OffsetDateTimeProvider_MaximumAllowedNegativeOffset_ConstructorDoesNotThrowException()
        {
            /* Create the test subject */
            TimeSpan maximumAllowedOffset = DateTime.Now - DateTime.MinValue;
            /* Build in a small safety margin */
            TimeSpan         offset      = new TimeSpan(maximumAllowedOffset.Ticks + 10);
            DateTimeProvider testSubject = new OffsetDateTimeProvider(offset);

            Assert.IsNotNull(testSubject);
        }
        public void OffsetDateTimeProvider_RegularNegativeOffset_TodayReturnsExpectedValue()
        {
            /* Create the test subject */
            TimeSpan         offset      = new TimeSpan(-2, 35, 42);
            DateTimeProvider testSubject = new OffsetDateTimeProvider(offset);

            DateTime testvalue     = testSubject.Today;
            DateTime expectedValue = DateTime.Now.AddHours(-2).AddMinutes(35).AddSeconds(42).Date;

            Assert.AreEqual(expectedValue, testvalue);
        }
        public void OffsetDateTimeProvider_ZeroOffset_TodayReturnsCurrentToday()
        {
            /* Create the test subject */
            TimeSpan         offset      = TimeSpan.Zero;
            DateTimeProvider testSubject = new OffsetDateTimeProvider(offset);

            DateTime testvalue     = testSubject.Today;
            DateTime expectedValue = DateTime.Today;

            Assert.AreEqual(expectedValue, testvalue);
        }
        public void OffsetDateTimeProvider_MaximumAllowedPositiveOffset_NowThrowsException()
        {
            /* Create the test subject */
            TimeSpan maximumAllowedOffset = DateTime.MaxValue - DateTime.Now;
            /* Build in a small safety margin */
            TimeSpan         offset      = new TimeSpan(maximumAllowedOffset.Ticks - 10);
            DateTimeProvider testSubject = new OffsetDateTimeProvider(offset);

            /* Wait a small amount of time (at least ten ticks) */
            Thread.Sleep(50);

            DateTime testvalue = testSubject.Now;
        }
        public void OffsetDateTimeProvider_RegularNegativeOffset_NowReturnsExpectedValue()
        {
            /* Create the test subject */
            TimeSpan         offset      = new TimeSpan(-2, 35, 42);
            DateTimeProvider testSubject = new OffsetDateTimeProvider(offset);

            DateTime testvalue     = testSubject.Now;
            DateTime expectedValue = DateTime.Now.AddHours(-2).AddMinutes(35).AddSeconds(42);

            /* Because test executions are not always performed with the same speed, the milliseconds are not considered in the equation */
            expectedValue = new DateTime(expectedValue.Year, expectedValue.Month, expectedValue.Day, expectedValue.Hour, expectedValue.Minute, expectedValue.Second);
            testvalue     = new DateTime(testvalue.Year, testvalue.Month, testvalue.Day, testvalue.Hour, testvalue.Minute, testvalue.Second);

            Assert.AreEqual(expectedValue, testvalue);
        }
        public void OffsetDateTimeProvider_ZeroOffset_UtcNowReturnsCurrentUtcNow()
        {
            /* Create the test subject */
            TimeSpan         offset      = TimeSpan.Zero;
            DateTimeProvider testSubject = new OffsetDateTimeProvider(offset);

            DateTime testvalue     = testSubject.UtcNow;
            DateTime expectedValue = DateTime.UtcNow;

            /* Because test executions are not always performed with the same speed, the milliseconds are not considered in the equation */
            expectedValue = new DateTime(expectedValue.Year, expectedValue.Month, expectedValue.Day, expectedValue.Hour, expectedValue.Minute, expectedValue.Second);
            testvalue     = new DateTime(testvalue.Year, testvalue.Month, testvalue.Day, testvalue.Hour, testvalue.Minute, testvalue.Second);

            Assert.AreEqual(expectedValue, testvalue);
        }
 public void OffsetDateTimeProvider_MinOffset_ConstructorThrowsException()
 {
     /* Create the test subject */
     TimeSpan         offset      = TimeSpan.MinValue;
     DateTimeProvider testSubject = new OffsetDateTimeProvider(offset);
 }