private static void InitCustomers()
        {
            DateTimeOffset dto = new DateTimeOffset(2015, 1, 1, 1, 2, 3, 4, TimeSpan.Zero);
            _customers = Enumerable.Range(1, 5).Select(e =>
                new DCustomer
                {
                    Id = e,
                    DateTime = dto.AddYears(e).DateTime,
                    Offset = e % 2 == 0 ? dto.AddMonths(e) : dto.AddDays(e).AddMilliseconds(10),
                    Date = e % 2 == 0 ? dto.AddDays(e).Date : dto.AddDays(-e).Date,
                    TimeOfDay = e % 3 == 0 ? dto.AddHours(e).TimeOfDay : dto.AddHours(-e).AddMilliseconds(10).TimeOfDay,

                    NullableDateTime = e % 2 == 0 ? (DateTime?)null : dto.AddYears(e).DateTime,
                    NullableOffset = e % 3 == 0 ? (DateTimeOffset?)null : dto.AddMonths(e),
                    NullableDate = e % 2 == 0 ? (Date?)null : dto.AddDays(e).Date,
                    NullableTimeOfDay = e % 3 == 0 ? (TimeOfDay?)null : dto.AddHours(e).TimeOfDay,

                    DateTimes = new [] { dto.AddYears(e).DateTime, dto.AddMonths(e).DateTime },
                    Offsets = new [] { dto.AddMonths(e), dto.AddDays(e) },
                    Dates = new [] { (Date)dto.AddYears(e).Date, (Date)dto.AddMonths(e).Date },
                    TimeOfDays = new [] { (TimeOfDay)dto.AddHours(e).TimeOfDay, (TimeOfDay)dto.AddMinutes(e).TimeOfDay },

                    NullableDateTimes = new [] { dto.AddYears(e).DateTime, (DateTime?)null, dto.AddMonths(e).DateTime },
                    NullableOffsets = new [] { dto.AddMonths(e), (DateTimeOffset?)null, dto.AddDays(e) },
                    NullableDates = new [] { (Date)dto.AddYears(e).Date, (Date?)null, (Date)dto.AddMonths(e).Date },
                    NullableTimeOfDays = new [] { (TimeOfDay)dto.AddHours(e).TimeOfDay, (TimeOfDay?)null, (TimeOfDay)dto.AddMinutes(e).TimeOfDay },

                }).ToList();
        }
        public void Between()
        {
            var date = new DateTimeOffset(2015, 8, 7, 13, 26, 30, TimeSpan.Zero);

            Assert.IsTrue(date.Between(date.AddMonths(-3), date.AddMonths(3)));
            Assert.IsTrue(date.AddHours(36).Between(date.AddMonths(-3), date.AddMonths(3)));
            Assert.IsFalse(date.AddMonths(6).Between(date.AddMonths(-3), date.AddMonths(3)));
            Assert.IsFalse(date.AddHours(-2).Between(date, date.AddMonths(3)));

            Assert.IsTrue(date.Between(date.AddMonths(-3), date.AddMonths(3), false));
            Assert.IsTrue(date.AddHours(36).Between(date.AddMonths(-3), date.AddMonths(3), false));
            Assert.IsFalse(date.AddMonths(6).Between(date.AddMonths(-3), date.AddMonths(3), false));
            Assert.IsTrue(date.AddHours(-2).Between(date, date.AddMonths(3), false));
            Assert.IsFalse(date.AddHours(-24).Between(date, date.AddMonths(3), false));
        }
Esempio n. 3
0
		internal long GetNextOccurrence()
		{
			DateTimeOffset now = _ClockSource.Now;
			DateTimeOffset next;

			switch (this.Periodicity)
			{
				case PeriodicityType.Hourly:
					next = new DateTimeOffset(now.Year, now.Month, now.Day, now.Hour, this.MinuteOffset, 0, now.Offset);

					if (next <= now)
					{
						next = next.AddHours(1.0);
					}

					break;

				case PeriodicityType.Daily:
					next = new DateTimeOffset(now.Year, now.Month, now.Day, this.HourOffset, this.MinuteOffset, 0, now.Offset);

					if (next <= now)
					{
						next = next.AddDays(1.0);
					}

					break;

				default:
					goto case PeriodicityType.Hourly;
			}

			return next.ToUniversalTime().Ticks;
		}
Esempio n. 4
0
 public void Dividing()
 {
     var now = new DateTimeOffset(2013, 8, 13, 13, 0, 0, TimeSpan.FromHours(12));
     var availableTime = new TimeRange(now, now.AddHours(1));
     var freeSlots = availableTime
         .Divide(TimeSpan.FromMinutes(15))
         .ToArray();
     Assert.AreEqual(4, freeSlots.Length);
     Assert.IsTrue(freeSlots.All(s => s.Duration == TimeSpan.FromMinutes(15)));
 }
Esempio n. 5
0
        public void CanAddHoursAcrossDstTransition()
        {
            var tz = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time");
            var dto = new DateTimeOffset(2015, 3, 8, 1, 0, 0, TimeSpan.FromHours(-8));
            var result = dto.AddHours(1, tz);

            var expected = new DateTimeOffset(2015, 3, 8, 3, 0, 0, TimeSpan.FromHours(-7));
            Assert.Equal(expected, result);
            Assert.Equal(expected.Offset, result.Offset);
        }
        /// <summary>
        /// Returns a value indicating whether the provided DaysOfWeek value is applicable today.
        /// </summary>
        public static bool IsToday(DaysOfWeek days, DateTimeOffset currentTime)
        {
            // special handling for Night Owl so that its schedule is visible after midnight
            // i.e., if it's 2AM on Sunday, we still consider "today" to be Saturday.
            var time = (days == DaysOfWeek.NightOwl)
                ? currentTime.AddHours(-4)
                : currentTime;

            return (ToDaysOfWeek(time.DayOfWeek) & days) != DaysOfWeek.None;
        }
Esempio n. 7
0
        static void Main(string[] args)
        {
            //var offset = DateTimeOffset.Now;
            //Debug.WriteLine(offset);

            //Debug.WriteLine(DateTimeOffset.UtcNow);

            //String s = "10/1/2014 6:17 PM";
            //DateTime dt = DateTime.ParseExact(s, "MM/dd/yyyy h:mm tt", CultureInfo.InvariantCulture);
            //DateTimeOffset dto = new DateTimeOffset(dt);
            DateTimeOffset dto1 = new DateTimeOffset();

            dto1 = DateTimeOffset.Now;
            dto1 = dto1.AddHours(2);
            dto1 = dto1.AddMinutes(30);

            Debug.WriteLine(DateTimeOffset.Now);
            Debug.WriteLine(dto1);

            TimeSpan diff = dto1.Subtract(DateTimeOffset.Now);
            Debug.WriteLine(diff);
            Debug.WriteLine(diff.TotalHours);
            Debug.WriteLine(diff.TotalSeconds);
            var diffsec = (DateTimeOffset.Now - dto1).TotalSeconds;
            Debug.WriteLine(diffsec);

            //dtoff.Value.ToLocalTime().ToString("dddd, MMM dd yyyy HH:mm", new CultureInfo("en-US"));

            //Debug.WriteLine(dto1);
            //Debug.WriteLine(dto2);
            //Debug.WriteLine(DateTimeOffset.Now);
            //Debug.WriteLine(dto1 - DateTimeOffset.Now);
            //Debug.WriteLine(DateTimeOffset.Now - dto1);
            //Debug.WriteLine(dto1.CompareTo(DateTimeOffset.Now));
            //Debug.WriteLine(DateTimeOffset.Now.CompareTo(dto1));
            //Debug.WriteLine("  ");

            //Debug.WriteLine(dto1.Hour);

            double temp = -26;
            double res = 0;
            for (int i = 0; i < 40; i++)
            {
                temp++;
                res = 0.5 - (temp * 0.1);
                Debug.WriteLine("Temp: " + temp + "  Result: " + res);
            }

            //Debug.WriteLine(s);
            //Debug.WriteLine(dt.ToString());
            //Debug.WriteLine(dt.ToUniversalTime().ToString());
            //Debug.WriteLine(dto.ToString());
        }
Esempio n. 8
0
        public void TestCronTriggerTimeZoneWillFire()
        {
            string         tzId         = "GMT Standard Time";
            TimeZoneInfo   tz           = TZConvert.GetTimeZoneInfo(tzId);
            TimeSpan       tzOffset     = tz.BaseUtcOffset;
            DateTimeOffset startDate    = new DateTimeOffset(new DateTime(2021, 1, 1, 0, 0, 0, DateTimeKind.Utc), tzOffset);
            DateTimeOffset expectedFire = startDate.AddHours(5).AddMinutes(50);

            CronTriggerImpl trigger = new CronTriggerImpl();

            trigger.Name                 = "Quartz-Custom";
            trigger.Group                = SchedulerConstants.DefaultGroup;
            trigger.TimeZone             = tz;
            trigger.CronExpressionString = "0 50 5,11,17,23 ? * *";
            trigger.StartTimeUtc         = startDate;

            Assert.AreEqual(expectedFire, trigger.GetFireTimeAfter(startDate), $"Expected to fire at {expectedFire}");
            Assert.IsTrue(trigger.WillFireOn(expectedFire), $"Expected to fire at {expectedFire}");
            Assert.IsTrue(trigger.WillFireOn(expectedFire.AddHours(6)), $"Expected to fire at {expectedFire}");
            Assert.IsTrue(trigger.WillFireOn(expectedFire.AddHours(12)), $"Expected to fire at {expectedFire}");
            Assert.IsTrue(trigger.WillFireOn(expectedFire.AddHours(18)), $"Expected to fire at {expectedFire}");
            Assert.IsTrue(trigger.WillFireOn(expectedFire.AddHours(24)), $"Expected to fire at {expectedFire}");
        }
Esempio n. 9
0
            public void SetsTheStopTimeToParameterStopTimeIfParameterHasStopTime(DateTimeOffset now)
            {
                var start     = now.AddHours(-4);
                var stop      = start.AddHours(2);
                var parameter = DurationParameter.WithStartAndDuration(start, stop - now);
                var observer  = TestScheduler.CreateObserver <DateTimeOffset>();

                ViewModel.StartTime.Subscribe(observer);

                ViewModel.Initialize(new EditDurationParameters(parameter));

                TestScheduler.Start();
                observer.LastEmittedValue().Should().BeSameDateAs(start);
            }
Esempio n. 10
0
        private void CrawlAllPlays(int minimumHoursPassed)
        {
            if (_lastTimeAllPlays.AddHours(minimumHoursPassed) > DateTimeOffset.Now)
            {
                return;
            }

            var plays = _geekConnector.GetPlays("kuhlschrank");

            Log($"{plays.Count()} plays found.");
            _repository.StorePlays(plays);
            Log($"{plays.Count()} plays updated.");
            _lastTimeAllPlays = DateTimeOffset.Now;
        }
            public void SetsTheStartTimeToTheValueReturnedByTheSelectDateTimeDialogViewModelWhenEditingARunningTimeEntry(DateTimeOffset now)
            {
                var parameterToReturn = DurationParameter.WithStartAndDuration(now.AddHours(-3), null);

                NavigationService
                .Navigate <DurationParameter, DurationParameter>(typeof(EditDurationViewModel), Arg.Any <DurationParameter>())
                .Returns(parameterToReturn);
                ConfigureEditedTimeEntry(now);
                ViewModel.Prepare(Id);

                ViewModel.EditDurationCommand.ExecuteAsync().Wait();

                ViewModel.StartTime.Should().Be(parameterToReturn.Start);
            }
Esempio n. 12
0
        public override DateTimeOffset?CalculateNextFireTime()
        {
            if (!prevFireTime.HasValue)
            {
                return(null);
            }
            if (maxRepeats != InfiniteRepeats && maxRepeats == context.TimesRun)
            {
                return(null);
            }
            if (finalFireTime.HasValue && finalFireTime < Time.Now())
            {
                return(null);
            }

            DateTimeOffset result = prevFireTime.Value;

            switch (Period)
            {
            case TimeInterval.Seconds:
                result = result.AddSeconds(interval);
                break;

            case TimeInterval.Minutes:
                result = result.AddMinutes(interval);
                break;

            case TimeInterval.Hours:
                result = result.AddHours(interval);
                break;

            case TimeInterval.Days:
                result = result.AddDays(interval);
                break;

            case TimeInterval.Weeks:
                result = result.AddDays(7 * interval);
                break;

            case TimeInterval.Months:
                result = result.AddMonths(interval);
                break;

            case TimeInterval.Years:
                result = result.AddYears(interval);
                break;
            }

            return(result);
        }
Esempio n. 13
0
            public void WhenChangedWhileUpdatingTheRunningTimeEntryTriggersTheUpdateOfTheStartTime(DateTimeOffset now)
            {
                var start     = now.AddHours(-2);
                var parameter = DurationParameter.WithStartAndStop(start, null);

                TimeService.CurrentDateTime.Returns(now);
                ViewModel.Prepare(parameter);

                ViewModel.Duration = TimeSpan.FromHours(4);

                var expectedStart = start.AddHours(-2);

                ViewModel.StartTime.Should().BeSameDateAs(expectedStart);
            }
Esempio n. 14
0
        //画像が削除されて意味がなくなったツイートを消す
        //URL転載したやつの転載元ツイートが消された場合
        public int RemoveOrphanTweet()
        {
            const int    BulkUnit      = 100;
            const int    RangeSeconds  = 300;
            const string head          = @"DELETE FROM tweet WHERE tweet_id IN";
            string       BulkDeleteCmd = BulkCmdStrIn(BulkUnit, head);

            TransformBlock <long, DataTable> GetTweetBlock = new TransformBlock <long, DataTable>(async(long id) =>
            {
                using (MySqlCommand Cmd = new MySqlCommand(@"SELECT tweet_id
FROM tweet
WHERE retweet_id IS NULL
AND NOT EXISTS (SELECT * FROM tweet_media WHERE tweet_media.tweet_id = tweet.tweet_id)
AND tweet_id BETWEEN @begin AND @end
ORDER BY tweet_id DESC;"))
                {
                    Cmd.Parameters.AddWithValue("@begin", id);
                    Cmd.Parameters.AddWithValue("@end", id + SnowFlake.msinSnowFlake * RangeSeconds * 1000 - 1);
                    return(await SelectTable(Cmd, IsolationLevel.RepeatableRead));
                }
            }, new ExecutionDataflowBlockOptions {
                MaxDegreeOfParallelism = Environment.ProcessorCount
            });


            DateTimeOffset date = DateTimeOffset.UtcNow.AddHours(-1);

            for (int i = 0; i < 20; i++)
            {
                GetTweetBlock.Post(SnowFlake.SecondinSnowFlake(date, false));
                date = date.AddHours(-1);
            }
            while (true)
            {
                DataTable Table = GetTweetBlock.Receive();
                if (Table.Rows.Count > 0)
                {
                    using (MySqlCommand delcmd = new MySqlCommand(BulkCmdStrIn(Table.Rows.Count, head)))
                    {
                        for (int n = 0; n < Table.Rows.Count; n++)
                        {
                            delcmd.Parameters.AddWithValue("@" + n.ToString(), Table.Rows[n].Field <long>(0));
                        }
                        Console.WriteLine("{0} {1} Tweets removed", date, ExecuteNonQuery(delcmd));
                    }
                }
                GetTweetBlock.Post(SnowFlake.SecondinSnowFlake(date, false));
                date = date.AddSeconds(-RangeSeconds);
            }
        }
Esempio n. 15
0
 public static DateTimeOffset RoundUpToClosestQuarter(this DateTimeOffset time)
 {
     if (time.Minute >= 45)
     {
         var nextHour = time.AddHours(1);
         return(new DateTimeOffset(nextHour.Year, nextHour.Month, nextHour.Day, nextHour.Hour, 0, 0, nextHour.Offset));
     }
     else
     {
         var offset = 15 - time.Minute % 15;
         var minute = time.Minute + offset;
         return(new DateTimeOffset(time.Year, time.Month, time.Day, time.Hour, minute, 0, time.Offset));
     }
 }
            public void ShouldBeFalseWhenRemoteConfigHasBeenFetchedLessThan12HoursAndHalfAgo()
            {
                var now = new DateTimeOffset(2019, 1, 1, 12, 0, 0, TimeSpan.Zero);

                TimeService.CurrentDateTime.Returns(now);
                var thirteenHoursAgo = now.AddHours(-11);

                KeyValueStorage.GetDateTimeOffset(LastFetchAtKey).Returns(thirteenHoursAgo);
                UpdateRemoteConfigCacheService = new UpdateRemoteConfigCacheService(TimeService, KeyValueStorage, FetchRemoteConfigService);

                var needsToUpdateStoredRemoteConfigData = UpdateRemoteConfigCacheService.NeedsToUpdateStoredRemoteConfigData();

                Assert.IsFalse(needsToUpdateStoredRemoteConfigData);
            }
Esempio n. 17
0
        public FormMoonRiver()
        {
            InitializeComponent();

            DateTimeOffset now      = DateTimeOffset.Now;
            DateTimeOffset thisHour = new DateTimeOffset(now.Year, now.Month, now.Day, now.Hour, 0, 0, now.Offset);

            intradaySince = thisHour.AddHours(-24);
            intradayUntil = thisHour.AddHours(24);
            interdaySince = new DateTimeOffset(now.Year, now.Month, now.Day, 0, 0, 0, TimeSpan.Zero).AddMonths(-1);
            interdayUntil = new DateTimeOffset(now.Year, now.Month, now.Day, 0, 0, 0, TimeSpan.Zero).AddMonths(1);


            InitiateGraphControl(geoIntraDay, intradaySince, intradayUntil);
            InitiateGraphControl(geoInterday, interdaySince, interdayUntil);


            addIntraDayCurves();

            markPlanetEvent();

            initializeEventsTab();
        }
Esempio n. 18
0
        public void GetJobsToRun_ReturnsJobs()
        {
            var dateTimeOffset     = new DateTimeOffset(DateTime.Today);
            var fromDateTimeOffset = dateTimeOffset.AddHours(-2);
            var toDateTimeOffset   = dateTimeOffset.AddHours(4).AddMilliseconds(-1);

            var jobsContext = new JobsContext();

            foreach (var jobItem in new[]
            {
                Midnight,
                EverydayAt0_OClock,
                EverydayAt4_OClock
            })
            {
                jobsContext.JobItems.Add(jobItem);
            }

            var jobStorageItems = jobsContext.GetJobsToRun(fromDateTimeOffset, toDateTimeOffset);

            Assert.Equal(3, jobsContext.JobItems.Count);
            Assert.Equal(2, jobStorageItems.Length);
        }
Esempio n. 19
0
            protected void ConfigureEditedTimeEntry(DateTimeOffset now, bool isRunning = false)
            {
                var te = TimeEntry.Builder.Create(Id)
                         .SetDescription("Something")
                         .SetStart(now.AddHours(-2))
                         .SetAt(now.AddHours(-2))
                         .SetWorkspaceId(11)
                         .SetUserId(12)
                         .SetProjectId(13)
                         .SetTaskId(14);

                if (!isRunning)
                {
                    te = te.SetDuration((long)Duration.TotalSeconds);
                }

                TheTimeEntry = te.Build();
                var observable = Observable.Return(TheTimeEntry);

                DataSource.TimeEntries.GetById(Arg.Is(Id)).Returns(observable);

                TimeService.CurrentDateTime.Returns(now);
            }
            public async Task ReturnsSuggestionsFromEventsOneHourInThePastAndOneHourInTheFuture()
            {
                var now = new DateTimeOffset(2020, 1, 2, 3, 4, 5, TimeSpan.Zero);

                TimeService.CurrentDateTime.Returns(now);
                var tenMinutes = TimeSpan.FromMinutes(10);
                var events     = Enumerable.Range(1, 5)
                                 .Select(id => new CalendarItem(
                                             id.ToString(),
                                             CalendarItemSource.Calendar,
                                             now - tenMinutes * id,
                                             tenMinutes,
                                             id.ToString(),
                                             CalendarIconKind.None));

                CalendarService
                .GetEventsInRange(Arg.Any <DateTimeOffset>(), Arg.Any <DateTimeOffset>())
                .Returns(Observable.Return(events));

                var userCalendar = new UserCalendar(
                    "",
                    "",
                    "",
                    true);

                InteractorFactory.GetUserCalendars().Execute()
                .Returns(Observable.Return(new List <UserCalendar> {
                    userCalendar
                }));

                var suggestions = await Provider.GetSuggestions().ToList();

                await CalendarService.Received().GetEventsInRange(now.AddHours(-1), now.AddHours(1));

                suggestions.Should().HaveCount(1)
                .And.OnlyContain(suggestion => events.Any(@event => @event.Description == suggestion.Description));
            }
        public static void RSACertificateNoPaddingMode()
        {
            using (RSA rsa = RSA.Create())
            {
                var request = new CertificateRequest(
                    new X500DistinguishedName("CN=Test"),
                    rsa,
                    HashAlgorithmName.SHA256,
                    RSASignaturePadding.Pkcs1);

                request.CertificateExtensions.Add(
                    new X509BasicConstraintsExtension(true, false, 0, true));

                DateTimeOffset now = DateTimeOffset.UtcNow;

                using (X509Certificate2 cert = request.CreateSelfSigned(now, now.AddDays(1)))
                {
                    request = new CertificateRequest(
                        new X500DistinguishedName("CN=Leaf"),
                        cert.PublicKey,
                        HashAlgorithmName.SHA256);

                    byte[] serialNumber = { 1, 1, 2, 3, 5, 8, 13 };

                    Assert.Throws <InvalidOperationException>(
                        () => request.Create(cert, now, now.AddHours(3), serialNumber));

                    X509SignatureGenerator generator =
                        X509SignatureGenerator.CreateForRSA(rsa, RSASignaturePadding.Pkcs1);

                    // Passes with the generator
                    using (request.Create(cert.SubjectName, generator, now, now.AddHours(3), serialNumber))
                    {
                    }
                }
            }
        }
    public void From_FromFixedDateTime_Tests(int value)
    {
        var originalPointInTime = new DateTimeOffset(1976, 12, 31, 17, 0, 0, 0, TimeSpan.Zero);

        Assert.AreEqual(value.Years().From(originalPointInTime), originalPointInTime.AddYears(value));
        Assert.AreEqual(value.Months().From(originalPointInTime), originalPointInTime.AddMonths(value));
        Assert.AreEqual(value.Weeks().From(originalPointInTime), originalPointInTime.AddDays(value*DaysPerWeek));
        Assert.AreEqual(value.Days().From(originalPointInTime), originalPointInTime.AddDays(value));

        Assert.AreEqual(value.Hours().From(originalPointInTime), originalPointInTime.AddHours(value));
        Assert.AreEqual(value.Minutes().From(originalPointInTime), originalPointInTime.AddMinutes(value));
        Assert.AreEqual(value.Seconds().From(originalPointInTime), originalPointInTime.AddSeconds(value));
        Assert.AreEqual(value.Milliseconds().From(originalPointInTime), originalPointInTime.AddMilliseconds(value));
        Assert.AreEqual(value.Ticks().From(originalPointInTime), originalPointInTime.AddTicks(value));
    }
            public TheIndexOfWithIdMethod()
            {
                mockCollection = new GroupedOrderedCollection <MockItem>(d => d.Id, d => d.Start.TimeOfDay, d => d.Start.Date, isDescending: true);
                List <MockItem> list = new List <MockItem>
                {
                    new MockItem {
                        Id = 0, Start = referenceDate.AddHours(3)
                    },
                    new MockItem {
                        Id = 1, Start = referenceDate.AddHours(1)
                    },
                    new MockItem {
                        Id = 2, Start = referenceDate.AddHours(-10)
                    },
                    new MockItem {
                        Id = 3, Start = referenceDate.AddDays(5)
                    },
                    new MockItem {
                        Id = 4, Start = referenceDate.AddDays(5).AddHours(2)
                    }
                };

                mockCollection.ReplaceWith(list);
            }
Esempio n. 24
0
        public async Task <List <OutstandingJobResult> > GetOutstandingOrTimedOutJobs(long?dcJobId,
                                                                                      DateTimeOffset startTime, CancellationToken cancellationToken)
        {
            var latestValidStartTime = startTime.AddHours(-2).AddMinutes(-30);

            return(await Jobs.Where(x =>
                                    x.DcJobId != dcJobId &&
                                    x.JobType == JobType.EarningsJob &&
                                    x.StartTime > latestValidStartTime).
                   Select(x => new OutstandingJobResult()
            {
                DcJobId = x.DcJobId, DcJobSucceeded = x.DcJobSucceeded, JobStatus = x.Status, EndTime = x.EndTime
            }).
                   ToListAsync(cancellationToken));
        }
Esempio n. 25
0
        public void Ago_FromFixedDateTime_Tests(int agoValue)
        {
            var originalPointInTime = new DateTimeOffset(1976, 12, 31, 17, 0, 0, 0, TimeSpan.Zero);

            Assert.AreEqual(agoValue.Years().Before(originalPointInTime), originalPointInTime.AddYears(-agoValue));
            Assert.AreEqual(agoValue.Months().Before(originalPointInTime), originalPointInTime.AddMonths(-agoValue));
            Assert.AreEqual(agoValue.Weeks().Before(originalPointInTime), originalPointInTime.AddDays(-agoValue * DAYS_PER_WEEK));
            Assert.AreEqual(agoValue.Days().Before(originalPointInTime), originalPointInTime.AddDays(-agoValue));

            Assert.AreEqual(agoValue.Hours().Before(originalPointInTime), originalPointInTime.AddHours(-agoValue));
            Assert.AreEqual(agoValue.Minutes().Before(originalPointInTime), originalPointInTime.AddMinutes(-agoValue));
            Assert.AreEqual(agoValue.Seconds().Before(originalPointInTime), originalPointInTime.AddSeconds(-agoValue));
            Assert.AreEqual(agoValue.Milliseconds().Before(originalPointInTime), originalPointInTime.AddMilliseconds(-agoValue));
            Assert.AreEqual(agoValue.Ticks().Before(originalPointInTime), originalPointInTime.AddTicks(-agoValue));
        }
Esempio n. 26
0
        private static async Task <string> GetStringCachedAsync(Uri targetUri, string cacheFileName)
        {
            string json = null;

            var localFolder = ApplicationData.Current.LocalFolder;

            var file = await localFolder.TryGetItemAsync(cacheFileName) as StorageFile;

            if (file != null)
            {
                var modifiedTime = (await file.GetBasicPropertiesAsync()).DateModified;

                var dateTimeOffsetNowJst   = DateTimeOffset.Now.ToOffset(TimeSpan.FromHours(9));
                var dateTimeOffsetTodayJst = new DateTimeOffset(dateTimeOffsetNowJst.Year, dateTimeOffsetNowJst.Month, dateTimeOffsetNowJst.Day, 0, 0, 0, TimeSpan.FromHours(9));

                var borderTime = (dateTimeOffsetNowJst.TimeOfDay < TimeSpan.FromHours(3))
                                        ? dateTimeOffsetTodayJst.AddHours(-21) // Yesterday 03:00:00 in JST
                                        : dateTimeOffsetTodayJst.AddHours(3);  // Today 03:00:00 in JST

                if (borderTime < modifiedTime)
                {
                    json = await FileIO.ReadTextAsync(file);
                }
            }

            if (String.IsNullOrEmpty(json))
            {
                json = await GetStringAsync(targetUri);

                file = await localFolder.CreateFileAsync(cacheFileName, CreationCollisionOption.ReplaceExisting);

                await FileIO.WriteTextAsync(file, json);
            }

            return(json);
        }
            public void ConvertsInputTimesFromZonesToLocalTimeForUseInUI(int offset)
            {
                var zoneOffset     = TimeSpan.FromHours(offset);
                var startTime      = new DateTimeOffset(2018, 1, 1, 13, 15, 22, zoneOffset);
                var stopTime       = startTime.AddHours(1);
                var localStartTime = startTime.ToLocalTime();
                var localStopTime  = stopTime.ToLocalTime();

                var parameter = CreateParameter(startTime, stopTime);

                ViewModel.Prepare(parameter);

                ViewModel.StartTime.Should().Be(localStartTime);
                ViewModel.StopTime.Should().Be(localStopTime);
            }
Esempio n. 28
0
    public void From_FromFixedDateTime_Tests(int value)
    {
        var originalPointInTime = new DateTimeOffset(1976, 12, 31, 17, 0, 0, 0, TimeSpan.Zero);

        Assert.AreEqual(value.Years().From(originalPointInTime), originalPointInTime.AddYears(value));
        Assert.AreEqual(value.Months().From(originalPointInTime), originalPointInTime.AddMonths(value));
        Assert.AreEqual(value.Weeks().From(originalPointInTime), originalPointInTime.AddDays(value * DaysPerWeek));
        Assert.AreEqual(value.Days().From(originalPointInTime), originalPointInTime.AddDays(value));

        Assert.AreEqual(value.Hours().From(originalPointInTime), originalPointInTime.AddHours(value));
        Assert.AreEqual(value.Minutes().From(originalPointInTime), originalPointInTime.AddMinutes(value));
        Assert.AreEqual(value.Seconds().From(originalPointInTime), originalPointInTime.AddSeconds(value));
        Assert.AreEqual(value.Milliseconds().From(originalPointInTime), originalPointInTime.AddMilliseconds(value));
        Assert.AreEqual(value.Ticks().From(originalPointInTime), originalPointInTime.AddTicks(value));
    }
            public void SetsTheStartTimeToCurrentTimeIfParameterDoesNotHaveStartTime(DateTimeOffset now)
            {
                var start     = now.AddHours(-2);
                var parameter = DurationParameter.WithStartAndDuration(start, null);

                TimeService.CurrentDateTime.Returns(now);
                var observer = TestScheduler.CreateObserver <DateTimeOffset>();

                ViewModel.StartTime.Subscribe(observer);

                ViewModel.Prepare(new EditDurationParameters(parameter));

                TestScheduler.Start();
                observer.LastValue().Should().BeSameDateAs(start);
            }
Esempio n. 30
0
 public void Time()
 {
     var date = new DateTimeOffset(year: 2016, month: 4, day: 1, hour: 1, minute: 0, second: 0, offset: TimeSpan.Zero);
     EqualityUnit
         .Create(new DateTimeKey(date, DateTimeKeyFlags.Time))
         .WithEqualValues(
             new DateTimeKey(date, DateTimeKeyFlags.Time),
             new DateTimeKey(date.AddDays(1), DateTimeKeyFlags.Time))
         .WithNotEqualValues(
             new DateTimeKey(date, DateTimeKeyFlags.Date),
             new DateTimeKey(date.AddHours(1), DateTimeKeyFlags.Time))
         .RunAll(
             (x, y) => x == y,
             (x, y) => x != y);
 }
Esempio n. 31
0
    public static void TestAddition()
    {
        DateTimeOffset dt = new DateTimeOffset(new DateTime(1986, 8, 15, 10, 20, 5, 70));
        Assert.Equal(17, dt.AddDays(2).Day);
        Assert.Equal(13, dt.AddDays(-2).Day);

        Assert.Equal(10, dt.AddMonths(2).Month);
        Assert.Equal(6, dt.AddMonths(-2).Month);

        Assert.Equal(1996, dt.AddYears(10).Year);
        Assert.Equal(1976, dt.AddYears(-10).Year);

        Assert.Equal(13, dt.AddHours(3).Hour);
        Assert.Equal(7, dt.AddHours(-3).Hour);

        Assert.Equal(25, dt.AddMinutes(5).Minute);
        Assert.Equal(15, dt.AddMinutes(-5).Minute);

        Assert.Equal(35, dt.AddSeconds(30).Second);
        Assert.Equal(2, dt.AddSeconds(-3).Second);

        Assert.Equal(80, dt.AddMilliseconds(10).Millisecond);
        Assert.Equal(60, dt.AddMilliseconds(-10).Millisecond);
    }
Esempio n. 32
0
        private static string GetParameter(ref DateTimeOffset startDateTimeOffset, int count, ProcessRequestBy processRequestBy)
        {
            switch (processRequestBy)
            {
            case ProcessRequestBy.Day:
                return("startDate="
                       + HttpUtility.UrlEncode(startDateTimeOffset.AddDays(count).ToString(_dateTimeOffsetFormat))
                       + "&endDate="
                       + HttpUtility.UrlEncode(startDateTimeOffset.AddDays(count + 1).ToString(_dateTimeOffsetFormat)));

            case ProcessRequestBy.Hour:
                return("startDate="
                       + HttpUtility.UrlEncode(startDateTimeOffset.AddHours(count).ToString(_dateTimeOffsetFormat))
                       + "&endDate="
                       + HttpUtility.UrlEncode(startDateTimeOffset.AddHours(count + 1).ToString(_dateTimeOffsetFormat)));

            case ProcessRequestBy.Second:
                return("startDate="
                       + HttpUtility.UrlEncode(startDateTimeOffset.AddSeconds(count).ToString(_dateTimeOffsetFormat))
                       + "&endDate="
                       + HttpUtility.UrlEncode(startDateTimeOffset.AddSeconds(count + 1).ToString(_dateTimeOffsetFormat)));
            }
            return(string.Empty);
        }
Esempio n. 33
0
        /// <summary>
        /// Testing RecurrentExample (see comment there) against a provided DateTimeOffset,
        /// trying what operations must be done to ensure that the DateTimeOffset is converted
        /// to the time as of the TimeZone rather than get it 'as is' (this will enable us to read
        /// database DateTimeOffsets that has an offset that doesn't match the Event or user time zone but
        /// must be converted to that before calculate occurrences).
        /// </summary>
        /// <returns></returns>
        static string OffsetRecurrentExample(string tz)
        {
            // We have a DateTime with an attached Offset, so the equivalent UTC time must be the same
            // on any tested time zone for a time not in the DST range,
            // it just changes the local value displayed and the calculations
            // of occurrences regarding DST (has or not DST, different DST date change).
            // Midday at UTC saved on UTC
            //var now = new DateTimeOffset(2016, 1, 1, 12, 0, 0, new TimeSpan(0, 0, 0));
            // Midday at UTC saved at PST (America/Los_Angeles)
            // -- results must be the same as when saved as UTC with the corrected time, as opposite to
            // the RecurrentExample method
            var now   = new DateTimeOffset(2016, 1, 1, 4, 0, 0, new TimeSpan(-8, 0, 0));
            var later = now.AddHours(1);

            var rrule = new RecurrencePattern(FrequencyType.Monthly, 1)
            {
                Count = 12
            };

            var timezone = NodaTime.DateTimeZoneProviders.Tzdb.GetZoneOrNull(tz);
            var znow     = new NodaTime.ZonedDateTime(NodaTime.Instant.FromDateTimeOffset(now), timezone);
            var start    = new CalDateTime(znow.LocalDateTime.ToDateTimeUnspecified(), tz);

            //Console.WriteLine("timezone {0}, znow: {1}, start: {2}", timezone, znow, start);

            var e = new Event
            {
                DtStart         = start,
                Duration        = new TimeSpan(1, 0, 0),
                RecurrenceRules = new List <IRecurrencePattern> {
                    rrule
                },
            };

            var calendar = new Calendar();

            calendar.Events.Add(e);

            //var serializer = new CalendarSerializer(new SerializationContext());
            //return serializer.SerializeToString(calendar);

            var endSearch = new DateTime(2017, 1, 1, 12, 0, 0).ToUniversalTime();

            return(calendar.GetOccurrences(now.UtcDateTime, endSearch).Aggregate("", (ret, a) =>
            {
                return ret + a.Period.StartTime.AsUtc.ToString() + "\n";
            }));
        }
Esempio n. 34
0
        public async Task <List <WeatherRecordModel> > GetActualWeatherRecord(string accessToken, DateTimeOffset currentDate)
        {
            var client = new HttpClient();

            client.DefaultRequestHeaders.Authorization =
                new AuthenticationHeaderValue("Bearer", accessToken);
            //validating certificate to use https
            ServicePointManager.ServerCertificateValidationCallback = CertificateValidation.MyRemoteCertificateValidationCallback;

            var month = (int.Parse(currentDate.Day.ToString()) == 1 &&
                         int.Parse(currentDate.Minute.ToString()) >= 0 &&
                         int.Parse(currentDate.Minute.ToString()) < 20 &&
                         int.Parse(currentDate.Hour.ToString()) == 0) ? currentDate.AddMonths(-1).Month : currentDate.Month;
            var year = (int.Parse(currentDate.Month.ToString()) == 1 &&
                        int.Parse(currentDate.Day.ToString()) == 1 &&
                        int.Parse(currentDate.Minute.ToString()) >= 0 &&
                        int.Parse(currentDate.Minute.ToString()) < 20 &&
                        int.Parse(currentDate.Hour.ToString()) == 0) ? currentDate.AddYears(-1).Year : currentDate.Year;
            var day = (int.Parse(currentDate.Minute.ToString()) >= 0 &&
                       int.Parse(currentDate.Minute.ToString()) < 20 &&
                       int.Parse(currentDate.Hour.ToString()) == 0) ? currentDate.AddDays(-1).Day : currentDate.Day;
            var hour = (int.Parse(currentDate.Minute.ToString()) >= 0 &&
                        int.Parse(currentDate.Minute.ToString()) < 20) ? currentDate.AddHours(-1).Hour : currentDate.Hour;

            var url = Constants.GetWeatherRecordsUrl + year + "-" + month + "-" + day + "T"
                      + hour.ToString("00.##") + ":" + currentDate.AddMinutes(-20).Minute.ToString("00.##") + ":00" + "/" + currentDate.Year + "-" + currentDate.Month + "-" + currentDate.Day + "T"
                      + currentDate.Hour.ToString("00.##") + ":" + currentDate.Minute.ToString("00.##") + ":00";
            List <WeatherRecordModel> weatherRecord;

            try
            {
                var json = await client.GetStringAsync(url);

                JObject jsonResponse = JObject.Parse(json);
                JArray  objResponse  = (JArray)jsonResponse["value"];

                weatherRecord = JsonConvert.DeserializeObject <List <WeatherRecordModel> >(objResponse.ToString());
            }
            catch (Exception e)
            {
                System.Diagnostics.Debug.WriteLine("Exception Message : " + e.Message
                                                   + " Instance that caused the current message : "
                                                   + e.InnerException + " Stack of Exception :"
                                                   + e.StackTrace);
                return(null);
            }
            return(weatherRecord);
        }
        public async Task ReturnsFinishedPersistingResultWhenThereAreNoProjectsWhichNeedRefetchingAndWereNotUpdatedWithinTheLastTwentyFourHours()
        {
            setStoredProjects(
                new MockProject {
                WorkspaceId = 1, SyncStatus = SyncStatus.RefetchingNeeded, At = now.AddHours(-23)
            },
                new MockProject {
                WorkspaceId = 1, SyncStatus = SyncStatus.RefetchingNeeded, At = now.AddHours(-10)
            },
                new MockProject {
                WorkspaceId = 1, SyncStatus = SyncStatus.RefetchingNeeded, At = now.AddHours(-2)
            },
                new MockProject {
                WorkspaceId = 1, SyncStatus = SyncStatus.RefetchingNeeded, At = now
            }
                );

            var transition = await state.Start(fetch);

            transition.Result.Should().Be(state.Done);
        }
            public async Task SchedulesEventsOnlyFromEnabledCalendars()
            {
                const int eventsPerCalendar = 4;
                var       now = new DateTimeOffset(2020, 1, 2, 3, 4, 5, TimeSpan.Zero);

                IEnumerable <CalendarItem> eventsForCalendar(UserCalendar calendar)
                {
                    return(Enumerable
                           .Range(1, eventsPerCalendar)
                           .Select(id => new CalendarItem(
                                       id.ToString(),
                                       CalendarItemSource.Calendar,
                                       now.AddHours(id),
                                       TimeSpan.FromHours(1),
                                       "description",
                                       CalendarIconKind.None,
                                       calendarId: calendar.Id
                                       )));
                }

                var calendars = Enumerable
                                .Range(0, 3)
                                .Select(id => id.ToString())
                                .Select(id => new UserCalendar(
                                            id,
                                            id,
                                            "Does not matter"
                                            ))
                                .ToArray();

                CalendarService.GetUserCalendars().Returns(Observable.Return(calendars));
                var events = calendars
                             .SelectMany(eventsForCalendar);

                CalendarService
                .GetEventsInRange(Arg.Any <DateTimeOffset>(), Arg.Any <DateTimeOffset>())
                .Returns(Observable.Return(events));
                UserPreferences.EnabledCalendarIds().Returns(new List <string> {
                    "1"
                });
                TimeService.CurrentDateTime.Returns(now);

                await interactor.Execute();

                await NotificationService.Received().Schedule(Arg.Is <ImmutableList <Notification> >(
                                                                  notifications => notifications.Count == eventsPerCalendar
                                                                  ));
            }
            public void SetsTheStopTimeToTheValueReturnedByTheSelectDateTimeDialogViewModelWhenEditingACompletedTimeEntry(DateTimeOffset now)
            {
                var start             = now.AddHours(-4);
                var duration          = TimeSpan.FromHours(1);
                var parameterToReturn = DurationParameter.WithStartAndDuration(start, duration);

                NavigationService
                .Navigate <EditDurationViewModel, DurationParameter, DurationParameter>(Arg.Any <DurationParameter>())
                .Returns(parameterToReturn);
                ConfigureEditedTimeEntry(now);
                ViewModel.Prepare(Id);

                ViewModel.EditDurationCommand.ExecuteAsync().Wait();

                ViewModel.Duration.Should().Be(parameterToReturn.Duration.Value);
            }
Esempio n. 38
0
            public void Time()
            {
                var date = new DateTimeOffset(year: 2016, month: 4, day: 1, hour: 1, minute: 0, second: 0, offset: TimeSpan.Zero);

                EqualityUnit
                .Create(new DateTimeKey(date, DateTimeKeyFlags.Time))
                .WithEqualValues(
                    new DateTimeKey(date, DateTimeKeyFlags.Time),
                    new DateTimeKey(date.AddDays(1), DateTimeKeyFlags.Time))
                .WithNotEqualValues(
                    new DateTimeKey(date, DateTimeKeyFlags.Date),
                    new DateTimeKey(date.AddHours(1), DateTimeKeyFlags.Time))
                .RunAll(
                    (x, y) => x == y,
                    (x, y) => x != y);
            }
Esempio n. 39
0
 private bool checkTime(DateTimeOffset now, DateTimeOffset check)
 {
     if (DateTimeOffset.Compare(now, check) < 0)
     {
         return(false);
     }
     check = check.AddHours(2);
     if (DateTimeOffset.Compare(now, check) <= 0)
     {
         return(true);
     }
     else
     {
         return(false);
     }
 }
Esempio n. 40
0
        public ValueTask <bool> CreateShowCalendarInviteAsync(DocsShow show)
        {
            DateTimeOffset showTime = show.Date !.Value;
            string         bodyText =
                $"<strong>🕚</strong> 30 mins before the show, work through the <a href='https://aka.ms/go-live-checklist'>go-live checklist</a>.<br>" +
                $"<strong>📺</strong> <a href='{show.GuestStreamUrl}'>Join the stream</a>.<br>" +
                $"<strong>👋</strong> <a href='https://dotnetdocs.dev/show/{show.Id}'>Share your episode to help boost viewership</a>.";

            return(PostJsonAsync(new
            {
                to = string.Join(";", show.Guests.Select(g => g.Email).Concat(new[] { "*****@*****.**" })),
                title = $"The .NET Docs Show: {show.Title}",
                body = bodyText,
                startTime = $"{showTime:yyyy-MM-ddThh:mm:ss}",
                endTime = $"{showTime.AddHours(1):yyyy-MM-ddThh:mm:ss}",
            },
        internal AdmiralRankingPoints(Admiral rpAdmiral)
        {
            r_Owner = rpAdmiral;
            r_AdmiralID = rpAdmiral.ID;

            ApiService.SubscribeOnce("api_port/port", delegate
            {
                ReloadInitialRankingPoints();

                PreviousUpdateDifference = new AdmiralRankingPointsDifference(this, AdmiralRankingPointsDifferenceType.PreviousUpdate);
                DayDifference = new AdmiralRankingPointsDifference(this, AdmiralRankingPointsDifferenceType.Day);
                MonthDifference = new AdmiralRankingPointsDifference(this, AdmiralRankingPointsDifferenceType.Month);

                Update();

                var rRankUpdateTime = new DateTimeOffset(DateTimeOffset.Now.Date, TimeSpan.FromHours(6.0));
                var rDayTimeSpan = TimeSpan.FromDays(1.0);
                Observable.Timer(rRankUpdateTime.AddDays(1.0), rDayTimeSpan).Subscribe(delegate
                {
                    PreviousUpdateDifference.Reload();
                    DayDifference.Reload();
                    OnPropertyChanged(nameof(PreviousUpdateDifference));
                    OnPropertyChanged(nameof(DayDifference));
                });

                rRankUpdateTime += TimeSpan.FromHours(12.0);
                if (DateTimeOffset.Now > rRankUpdateTime)
                    rRankUpdateTime += rDayTimeSpan;
                Observable.Timer(rRankUpdateTime, rDayTimeSpan).Subscribe(delegate
                {
                    PreviousUpdateDifference.Reload();
                    OnPropertyChanged(nameof(PreviousUpdateDifference));
                });

                var rNow = DateTimeOffset.Now;
                var rFinalizationTime = new DateTimeOffset(rNow.Year, rNow.Month, 1, 0, 0, 0, TimeSpan.FromHours(9.0)).AddMonths(1).AddHours(-2.0);
                if (rNow >= rFinalizationTime)
                    FinalizeThisMonth();
                else
                    Observable.Return(Unit.Default).Delay(rFinalizationTime).Subscribe(_ => FinalizeThisMonth());

                Observable.Return(Unit.Default).Delay(rFinalizationTime.AddHours(2.0)).Subscribe(_ => r_IsFinalized = false);

                RecordService.Instance.Update += RecordService_Update;
            });
        }
Esempio n. 42
0
        void Snippets()
        {
            #region Dividing
            var now = new DateTimeOffset(2013, 8, 13, 13, 0, 0, TimeSpan.FromHours(12));
            var availableTime = new TimeRange(now, now.AddHours(1));
            var freeSlots = availableTime.Divide(TimeSpan.FromMinutes(15));
            foreach (var freeSlot in freeSlots)
            {
                Console.WriteLine(freeSlot);
            }

            // Produces 4 15 minute time ranges.
            //
            // 13 Aug 2013 1:00:00 p.m. +12:00 for 00:15:00
            // 13 Aug 2013 1:15:00 p.m. +12:00 for 00:15:00
            // 13 Aug 2013 1:30:00 p.m. +12:00 for 00:15:00
            // 13 Aug 2013 1:45:00 p.m. +12:00 for 00:15:00
            #endregion
        }
Esempio n. 43
0
 private static DateTimeOffset TranslatedAdd(DateTimeOffset date, IntervalUnit unit, int amountToAdd)
 {
     switch (unit)
     {
         case IntervalUnit.Day:
             return date.AddDays(amountToAdd);
         case IntervalUnit.Hour:
             return date.AddHours(amountToAdd);
         case IntervalUnit.Minute:
             return date.AddMinutes(amountToAdd);
         case IntervalUnit.Month:
             return date.AddMonths(amountToAdd);
         case IntervalUnit.Second:
             return date.AddSeconds(amountToAdd);
         case IntervalUnit.Millisecond:
             return date.AddMilliseconds(amountToAdd);
         case IntervalUnit.Week:
             return date.AddDays(amountToAdd*7);
         case IntervalUnit.Year:
             return date.AddYears(amountToAdd);
         default:
             throw new ArgumentException("Unknown IntervalUnit");
     }
 }
		public static DateTimeOffset Round(this DateTimeOffset dateTime, RoundTo rt)
		{
			DateTimeOffset rounded;

		    switch (rt)
			{
				case RoundTo.Second:
					{
                        rounded = new DateTimeOffset(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute, dateTime.Second,dateTime.Offset);
						if (dateTime.Millisecond >= 500)
						{
							rounded = rounded.AddSeconds(1);
						}
						break;
					}
				case RoundTo.Minute:
					{
                        rounded = new DateTimeOffset(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, dateTime.Minute, 0,dateTime.Offset);
						if (dateTime.Second >= 30)
						{
							rounded = rounded.AddMinutes(1);
						}
						break;
					}
				case RoundTo.Hour:
					{
                        rounded = new DateTimeOffset(dateTime.Year, dateTime.Month, dateTime.Day, dateTime.Hour, 0, 0,dateTime.Offset);
						if (dateTime.Minute >= 30)
						{
							rounded = rounded.AddHours(1);
						}
						break;
					}
				case RoundTo.Day:
					{
                        rounded = new DateTimeOffset(dateTime.Year, dateTime.Month, dateTime.Day, 0, 0, 0,dateTime.Offset);
						if (dateTime.Hour >= 12)
						{
							rounded = rounded.AddDays(1);
						}
						break;
					}
				default:
					{
                        throw new ArgumentOutOfRangeException("rt");
					}
			}

			return rounded;
		}
        public void When_date_is_not_at_least_one_day_before_another_it_should_throw()
        {
            //-----------------------------------------------------------------------------------------------------------
            // Arrange
            //-----------------------------------------------------------------------------------------------------------
            var target = new DateTimeOffset(2.October(2009), 0.Hours());
            DateTimeOffset subject = target.AddHours(-23);

            //-----------------------------------------------------------------------------------------------------------
            // Act
            //-----------------------------------------------------------------------------------------------------------
            Action act = () => subject.Should().BeAtLeast(TimeSpan.FromDays(1)).Before(target, "we like {0}", "that");

            //-----------------------------------------------------------------------------------------------------------
            // Assert
            //-----------------------------------------------------------------------------------------------------------
            act.ShouldThrow<AssertFailedException>().WithMessage(
                "Expected date and/or time <2009-10-01 01:00:00> to be at least 1d before <2009-10-02> because we like that, but it differs 23h.");
        }
Esempio n. 46
0
        public void TestHourlyIntervalGetFireTimeAfter()
        {
            DateTimeOffset startCalendar = new DateTimeOffset(2005, 6, 1, 9, 30, 17, TimeSpan.Zero);

            CalendarIntervalTriggerImpl yearlyTrigger = new CalendarIntervalTriggerImpl();
            yearlyTrigger.StartTimeUtc = startCalendar;
            yearlyTrigger.RepeatIntervalUnit = IntervalUnit.Hour;
            yearlyTrigger.RepeatInterval = 100; // every 100 hours

            DateTimeOffset targetCalendar = new DateTimeOffset(2005, 6, 1, 9, 30, 17, TimeSpan.Zero);

            targetCalendar = targetCalendar.AddHours(400); // jump 400 hours (4 intervals)

            IList<DateTimeOffset> fireTimes = TriggerUtils.ComputeFireTimes(yearlyTrigger, null, 6);
            DateTimeOffset fifthTime = fireTimes[4]; // get the fifth fire time

            Assert.AreEqual(targetCalendar, fifthTime, "Hour increment result not as expected.");
        }
Esempio n. 47
0
        private async Task CreateTimerResults(TimerCounter timerCounter)
        {
            var userId = await GetUserId();

            if (timerCounter == null) return;

            try
            {
                // remove previous results, if any
                var results = await _context.TimerResults.Where(e => e.TimerCounterId == timerCounter.TimerCounterId && e.DiteUserId == userId).ToListAsync();
                if (results != null) _context.TimerResults.RemoveRange(results);
            }
            catch (Exception ex)
            {
                // required connection string parameter - MultipleActiveResultSets=True
                throw new Exception("error removing old results", ex);
            }

            DateTimeOffset localStart = timerCounter.TimerStartLocal;
            DateTimeOffset localEnd = timerCounter.TimerEndLocal;

            // first end
            var nextEnd = new DateTimeOffset(localStart.Year, localStart.Month, localStart.Day, localStart.Hour, 0, 0, localStart.Offset);
            nextEnd = nextEnd.AddHours(1);

            if(nextEnd>localEnd)
            {
                // within same hour; only result
                TimerResult result = NewTimerResult(timerCounter, userId, localStart, localEnd);
                _context.TimerResults.Add(result);
                return;
            }
            else
            {
                // first hour; first result
                TimerResult result = NewTimerResult(timerCounter, userId, localStart, nextEnd);
                _context.TimerResults.Add(result);
               
                // sequence
                var nextStart = new DateTimeOffset(localStart.Year, localStart.Month, localStart.Day, localStart.Hour, 0, 0, localStart.Offset);

                while ((nextStart = nextStart.AddHours(1)) < localEnd 
                    && ((nextEnd = nextEnd.AddHours(1)) < localEnd))
                {
                    var seqResult = NewTimerResult(timerCounter, userId, nextStart, nextEnd);
                    _context.TimerResults.Add(seqResult);
                }

                // last hour; last result
                TimerResult resultLast = NewTimerResult(timerCounter, userId, nextStart, localEnd);
                _context.TimerResults.Add(resultLast);

            }
        }
Esempio n. 48
0
        public static CharacterModel GetCharacter(RegionsLookup region, string server, string name)
        {
            string key = string.Format("character_{0}_{1}_{2}", region, server, name);

            ObjectCache cache = MemoryCache.Default;
            CharacterModel item = cache[key] as CharacterModel;

            if (item == null)
            {
                string requestUrl = string.Format("{0}/character/{1}/{2}", GetBaseRequestURL(region), server, name);

                try
                {
                    WebClient client = new WebClient();
                    string result = client.DownloadString(requestUrl);

                    DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(CharacterModel));

                    using (MemoryStream ms = new MemoryStream(Encoding.Unicode.GetBytes(result)))
                    {
                        item = serializer.ReadObject(ms) as CharacterModel;
                    }

                    DateTimeOffset dto = new DateTimeOffset();

                    dto.AddHours(1);

                    cache.Set(key, item, DateTimeOffset.Now.AddMinutes(30));
                }
                catch (Exception ex)
                {
                }
            }

            return item;
        }
        public IHttpActionResult ResetDataSource()
        {
            DateAndTimeOfDayContext db = new DateAndTimeOfDayContext();
            if (!db.Customers.Any())
            {
                DateTimeOffset dateTime = new DateTimeOffset(2014, 12, 24, 1, 2, 3, 4, new TimeSpan(-8, 0, 0));
                IEnumerable<EfCustomer> customers = Enumerable.Range(1, 5).Select(e =>
                    new EfCustomer
                    {
                        Id = e,
                        DateTime = dateTime.AddYears(e).AddHours(e).AddMilliseconds(e).DateTime,
                        NullableDateTime = e % 2 == 0 ? (DateTime?)null : dateTime.AddHours(e * 5).AddMilliseconds(e * 5).DateTime,
                        Offset = dateTime.AddMonths(e).AddHours(e).AddMilliseconds(e),
                        NullableOffset = e % 3 == 0 ? (DateTimeOffset?)null : dateTime.AddDays(e).AddHours(e * 5)
                    }).ToList();

                foreach (EfCustomer customer in customers)
                {
                    db.Customers.Add(customer);
                }

                db.SaveChanges();
            }

            return Ok();
        }
Esempio n. 50
0
 public static void AddHours(DateTimeOffset dateTimeOffset, double hours, DateTimeOffset expected)
 {
     Assert.Equal(expected, dateTimeOffset.AddHours(hours));
 }
        public void When_date_is_at_least_one_day_before_another_it_should_not_throw()
        {
            //-----------------------------------------------------------------------------------------------------------
            // Arrange
            //-----------------------------------------------------------------------------------------------------------
            var target = new DateTimeOffset(2.October(2009));
            DateTimeOffset subject = target.AddHours(-24);

            //-----------------------------------------------------------------------------------------------------------
            // Act / Assert
            //-----------------------------------------------------------------------------------------------------------
            subject.Should().BeAtLeast(TimeSpan.FromDays(1)).Before(target);
        }
		/// <summary>
		/// Initializes a new instance of the <see cref="OneTimeToken"/> class.
		/// Recreates a previously issued token for verification
		/// </summary>
		/// <param name="key">The key.</param>
		/// <param name="tokenStamp">The token stamp.</param>
		/// <param name="expiration">The expiration.</param>
		/// <exception cref="ArgumentNullException">
		/// </exception>
		public OneTimeToken(byte[] key, byte[] tokenStamp, DateTimeOffset expiration)
		{
			if (key != null || key.Length <= 0)
			{
				_hmacSha = new HMACSHA256(key);

				if (tokenStamp != null || tokenStamp.Length <= 0)
				{
					TokenStamp = tokenStamp;
				}
				else
				{
					throw new ArgumentNullException(nameof(tokenStamp));
				}

				_rng = System.Security.Cryptography.RandomNumberGenerator.Create();

				_issueTime = expiration.AddHours(-1);
			}
			else
			{
				throw new ArgumentNullException(nameof(key));
			}
		}
Esempio n. 53
0
        public void Subtracting()
        {
            var now = new DateTimeOffset(2013, 8, 13, 13, 0, 0, TimeSpan.FromHours(12));
            var tick = new TimeSpan(1);
            var time = new TimeRange(now, now.AddHours(1));
            var before = new TimeRange(now - TimeSpan.FromHours(1), time.StartsOn);
            var after = new TimeRange(time.EndsOn, TimeSpan.FromHours(1));
            var mid = new TimeRange(now.AddMinutes(15), TimeSpan.FromMinutes(30));

            // No intersection
            Assert.AreEqual(1, time.Subtract(before).Count());
            Assert.AreEqual(time, time.Subtract(before).First());
            Assert.AreEqual(1, time.Subtract(after).Count());
            Assert.AreEqual(time, time.Subtract(after).First());

            // Identity
            Assert.AreEqual(0, time.Subtract(time).Count());

            // Subsumes
            Assert.AreEqual(0, time.Subtract(new TimeRange(before.StartsOn, after.EndsOn)).Count());

            // Middle
            Assert.AreEqual(2, time.Subtract(mid).Count());
            Assert.IsTrue(time.Subtract(mid).Any(t => t.StartsOn == now && t.Duration == TimeSpan.FromMinutes(15)));
            Assert.IsTrue(time.Subtract(mid).Any(t => t.StartsOn == now.AddMinutes(45) && t.Duration == TimeSpan.FromMinutes(15)));
        }
        public void When_date_is_not_within_50_hours_before_another_date_it_should_throw()
        {
            //-----------------------------------------------------------------------------------------------------------
            // Arrange
            //-----------------------------------------------------------------------------------------------------------
            var target = new DateTimeOffset(10.April(2010).At(12, 0), 0.Hours());
            DateTimeOffset subject = target.AddHours(-50).AddSeconds(-1);

            //-----------------------------------------------------------------------------------------------------------
            // Act
            //-----------------------------------------------------------------------------------------------------------
            Action act =
                () => subject.Should().BeWithin(TimeSpan.FromHours(50)).Before(target, "{0} hours is enough", 50);

            //-----------------------------------------------------------------------------------------------------------
            // Assert
            //-----------------------------------------------------------------------------------------------------------
            act.ShouldThrow<AssertFailedException>().WithMessage(
                "Expected date and/or time <2010-04-08 09:59:59> to be within 2d and 2h before <2010-04-10 12:00:00> because 50 hours is enough, but it differs 2d, 2h and 1s.");
        }
        /// <summary>
        /// Returns an enumerable collection of log blobs containing Analytics log records. The blobs are retrieved lazily.
        /// </summary>
        /// <param name="service">A <see cref="StorageService"/> enumeration value.</param>
        /// <param name="startTime">A <see cref="DateTimeOffset"/> object representing the start of the time range for which logs should be retrieved.</param>
        /// <param name="endTime">A <see cref="DateTimeOffset"/> object representing the end of the time range for which logs should be retrieved.</param>
        /// <param name="operations">A <see cref="LoggingOperations"/> enumeration value that indicates the types of logging operations on which to filter the log blobs.</param>
        /// <param name="details">A <see cref="BlobListingDetails"/> enumeration value that indicates whether or not blob metadata should be returned. Only <c>None</c> and <c>Metadata</c> are valid values. </param>
        /// <param name="options">A <see cref="BlobRequestOptions"/> object that specifies additional options for the request.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
        /// <returns>An enumerable collection of objects that implement <see cref="ICloudBlob"/> and are retrieved lazily.</returns>
        /// <remarks>Note that specifying a logging operation type for the <paramref name="operations"/> parameter will return any Analytics log blob that contains the specified logging operation,
        /// even if that log blob also includes other types of logging operations. Also note that the only currently supported values for the <paramref name="details"/> 
        /// parameter are <c>None</c> and <c>Metadata</c>.</remarks>
        public IEnumerable<ICloudBlob> ListLogs(StorageService service, DateTimeOffset startTime, DateTimeOffset? endTime, LoggingOperations operations, BlobListingDetails details, BlobRequestOptions options, OperationContext operationContext)
        {
            CloudBlobDirectory logDirectory = this.GetLogDirectory(service);
            BlobListingDetails metadataDetails = details;
            DateTimeOffset utcStartTime = startTime.ToUniversalTime();
            DateTimeOffset dateCounter = new DateTimeOffset(utcStartTime.Ticks - (utcStartTime.Ticks % TimeSpan.TicksPerHour), utcStartTime.Offset);
            DateTimeOffset? utcEndTime = null;
            string endPrefix = null;

            // Ensure that the date range is correct.
            if (endTime.HasValue)
            {
                utcEndTime = endTime.Value.ToUniversalTime();
                endPrefix = logDirectory.Prefix + utcEndTime.Value.ToString("yyyy/MM/dd/HH", CultureInfo.InvariantCulture);
                if (utcStartTime > utcEndTime.Value)
                {
                    string errorString = string.Format(CultureInfo.InvariantCulture, SR.StartTimeExceedsEndTime, startTime, endTime.Value);
                    throw new ArgumentException(errorString);
                }
            }

            // Currently only support the ability to retrieve metadata on logs.
            if (details.HasFlag(BlobListingDetails.Copy) || details.HasFlag(BlobListingDetails.Snapshots) || details.HasFlag(BlobListingDetails.UncommittedBlobs))
            {
                throw new ArgumentException(SR.InvalidListingDetails);
            }

            // At least one LogType must be specified.
            if (operations == LoggingOperations.None)
            {
                throw new ArgumentException(SR.InvalidLoggingLevel);
            }

            // If metadata or a specific LogType is specified, metadata should be retrieved.
            if (details.HasFlag(BlobListingDetails.Metadata) || !operations.HasFlag(LoggingOperations.All))
            {
                metadataDetails = BlobListingDetails.Metadata;
            }

            // Check logs using an hour-based prefix until we reach a day boundary.
            while (dateCounter.Hour > 0)
            {
                string currentPrefix = logDirectory.Prefix + dateCounter.ToString("yyyy/MM/dd/HH", CultureInfo.InvariantCulture);
                IEnumerable<IListBlobItem> currentLogs = logDirectory.Container.ListBlobs(currentPrefix, true, metadataDetails, options, operationContext);

                foreach (ICloudBlob log in currentLogs)
                {
                    if (!utcEndTime.HasValue || string.Compare(log.Parent.Prefix, endPrefix) <= 0)
                    {
                        if (IsCorrectLogType(log, operations))
                        {
                            yield return log;
                        }
                    }
                    else
                    {
                        yield break;
                    }
                }

                dateCounter = dateCounter.AddHours(1);
                if (dateCounter > DateTimeOffset.UtcNow.AddHours(1))
                {
                    yield break;
                }
            }

            // Check logs using a day-based prefix until we reach a month boundary.
            while (dateCounter.Day > 1)
            {
                string currentPrefix = logDirectory.Prefix + dateCounter.ToString("yyyy/MM/dd", CultureInfo.InvariantCulture);
                IEnumerable<IListBlobItem> currentLogs = logDirectory.Container.ListBlobs(currentPrefix, true, metadataDetails, options, operationContext);

                foreach (ICloudBlob log in currentLogs)
                {
                    if (!utcEndTime.HasValue || string.Compare(log.Parent.Prefix, endPrefix) <= 0)
                    {
                        if (IsCorrectLogType(log, operations))
                        {
                            yield return log;
                        }
                    }
                    else
                    {
                        yield break;
                    }
                }

                dateCounter = dateCounter.AddDays(1);
                if (dateCounter > DateTimeOffset.UtcNow.AddHours(1))
                {
                    yield break;
                }
            }

            // Check logs using a month-based prefix until we reach a year boundary.
            while (dateCounter.Month > 1)
            {
                string currentPrefix = logDirectory.Prefix + dateCounter.ToString("yyyy/MM", CultureInfo.InvariantCulture);
                IEnumerable<IListBlobItem> currentLogs = logDirectory.Container.ListBlobs(currentPrefix, true, metadataDetails, options, operationContext);

                foreach (ICloudBlob log in currentLogs)
                {
                    if (!utcEndTime.HasValue || string.Compare(log.Parent.Prefix, endPrefix) <= 0)
                    {
                        if (IsCorrectLogType(log, operations))
                        {
                            yield return log;
                        }
                    }
                    else
                    {
                        yield break;
                    }
                }

                dateCounter = dateCounter.AddMonths(1);
                if (dateCounter > DateTimeOffset.UtcNow.AddHours(1))
                {
                    yield break;
                }
            }

            // Continue using a year-based prefix. 
            while (true)
            {
                string currentPrefix = logDirectory.Prefix + dateCounter.ToString("yyyy", CultureInfo.InvariantCulture);
                IEnumerable<IListBlobItem> currentLogs = logDirectory.Container.ListBlobs(currentPrefix, true, metadataDetails, options, operationContext);

                foreach (ICloudBlob log in currentLogs)
                {
                    if (!utcEndTime.HasValue || string.Compare(log.Parent.Prefix, endPrefix) <= 0)
                    {
                        if (IsCorrectLogType(log, operations))
                        {
                            yield return log;
                        }
                    }
                    else
                    {
                        yield break;
                    }
                }

                dateCounter = dateCounter.AddYears(1);
                if (dateCounter > DateTimeOffset.UtcNow.AddHours(1))
                { 
                    yield break;
                }
            }
        }
        public void TestTimeZone()
        {
            TimeZoneInfo GMT = TimeZoneInfo.FindSystemTimeZoneById("GMT Standard Time");
            TimeZoneInfo EST = TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time");

            // Calendar startTime = Calendar.getInstance(EST);
            var startTime = new DateTime(2006, 3, 7, 7, 0, 0, DateTimeKind.Utc);
            startTime = TimeZoneInfo.ConvertTimeFromUtc(startTime, EST);

            // Same timezone
            {
                NthIncludedDayTrigger t = new NthIncludedDayTrigger("name", "group");
                t.IntervalType = NthIncludedDayTrigger.IntervalTypeWeekly;
                t.N = 3;
                t.StartTimeUtc = startTime.ToUniversalTime();
                t.FireAtTime = "8:00";
                t.TimeZone = EST;

                DateTimeOffset? firstTime = t.ComputeFirstFireTimeUtc(null);

                // Calendar firstTimeCal = Calendar.getInstance(EST);
                DateTime firstTimeCal = new DateTime(startTime.Year, startTime.Month, startTime.Day, 8, 0, 0, 0, DateTimeKind.Utc);
                firstTimeCal = TimeZoneInfo.ConvertTimeFromUtc(firstTimeCal, EST);
                //roll start date forward to first day of the next week
                while (firstTimeCal.DayOfWeek != t.TriggerCalendarFirstDayOfWeek)
                {
                    firstTimeCal = firstTimeCal.AddDays(-1);
                }

                //first day of the week counts as one. add two more to get N=3.
                firstTimeCal = firstTimeCal.AddDays(2);

                //if we went back too far, shift forward a week.
                if (firstTimeCal < startTime)
                {
                    firstTimeCal = firstTimeCal.AddDays(7);
                }

                Assert.AreEqual(firstTime, firstTimeCal);
            }

            // Different timezones
            {
                NthIncludedDayTrigger t = new NthIncludedDayTrigger("name", "group");
                t.IntervalType = NthIncludedDayTrigger.IntervalTypeWeekly;
                t.N = 3;
                t.StartTimeUtc = startTime;
                t.FireAtTime = "8:00";
                t.TimeZone = GMT;

                DateTimeOffset? firstTime = t.ComputeFirstFireTimeUtc(null);
                // Calendar firstTimeCal = Calendar.getInstance(EST);
                DateTimeOffset firstTimeCal = new DateTimeOffset(startTime.Year, startTime.Month, startTime.Day, 8, 0, 0, 0, TimeSpan.Zero);

                //EST is GMT-5
                firstTimeCal.AddHours(-5);

                //roll start date forward to first day of the next week
                while (firstTimeCal.DayOfWeek != t.TriggerCalendarFirstDayOfWeek)
                {
                    firstTimeCal = firstTimeCal.AddDays(-1);
                }

                //first day of the week counts as one. add two more to get N=3.
                firstTimeCal = firstTimeCal.AddDays(2);

                //if we went back too far, shift forward a week.
                if (firstTimeCal < startTime)
                {
                    firstTimeCal = firstTimeCal.AddDays(7);
                }

                Assert.AreEqual(firstTime, firstTimeCal);
            }
        }
        public void When_a_value_is_not_one_of_the_specified_values_it_should_throw()
        {
            //-----------------------------------------------------------------------------------------------------------
            // Arrange
            //-----------------------------------------------------------------------------------------------------------
            var value = new DateTimeOffset(31.December(2016), 1.Hours());
            //-----------------------------------------------------------------------------------------------------------
            // Act
            //-----------------------------------------------------------------------------------------------------------
            Action action = () => value.Should().BeOneOf(value.AddDays(1), value.AddHours(4));

            //-----------------------------------------------------------------------------------------------------------
            // Assert
            //-----------------------------------------------------------------------------------------------------------
            action.ShouldThrow<AssertFailedException>()
                .WithMessage("Expected value to be one of {<2017-01-01 +1h>, <2016-12-31 04:00:00 +1h>}, but found <2016-12-31 +1h>.");
        }
        public void ToRelativeTimeTest()
        {
            var date = new DateTimeOffset(2015, 8, 7, 13, 26, 30, TimeSpan.Zero);
            var now = DateTimeOffset.Now;

            Assert.AreEqual("now", now.ToRelativeTimeString());
            Assert.AreEqual("now", now.ToRelativeTimeString(now));

            Assert.AreEqual("1 second ago", date.AddSeconds(-1).ToRelativeTimeString(date));
            Assert.AreEqual("10 seconds ago", date.AddSeconds(-10).ToRelativeTimeString(date));
            Assert.AreEqual("1 minute ago", date.AddSeconds(-90).ToRelativeTimeString(date));
            Assert.AreEqual("1 minute ago", date.AddSeconds(-100).ToRelativeTimeString(date));
            Assert.AreEqual("2 minutes ago", date.AddSeconds(-120).ToRelativeTimeString(date));
            Assert.AreEqual("7 minutes ago", date.AddMinutes(-7).ToRelativeTimeString(date));
            Assert.AreEqual("59 minutes ago", date.AddMinutes(-59).ToRelativeTimeString(date));
            Assert.AreEqual("1 hour ago", date.AddMinutes(-60).ToRelativeTimeString(date));
            Assert.AreEqual("1 hour ago", date.AddHours(-1).ToRelativeTimeString(date));
            Assert.AreEqual("9 hours ago", date.AddHours(-9).ToRelativeTimeString(date));
            Assert.AreEqual("1 day ago", date.AddHours(-24).ToRelativeTimeString(date));
            Assert.AreEqual("1 day ago", date.AddHours(-30).ToRelativeTimeString(date));
            Assert.AreEqual("2 days ago", date.AddHours(-48).ToRelativeTimeString(date));
            Assert.AreEqual("1 day ago", date.AddDays(-1).ToRelativeTimeString(date));
            Assert.AreEqual("12 days ago", date.AddDays(-12).ToRelativeTimeString(date));
            Assert.AreEqual("29 days ago", date.AddDays(-29).ToRelativeTimeString(date));
            Assert.AreEqual("1 month ago", date.AddDays(-30).ToRelativeTimeString(date));
            Assert.AreEqual("1 month ago", date.AddMonths(-1).ToRelativeTimeString(date));
            Assert.AreEqual("3 months ago", date.AddMonths(-3).ToRelativeTimeString(date));
            Assert.AreEqual("11 months ago", date.AddMonths(-11).ToRelativeTimeString(date));
            Assert.AreEqual("1 year ago", date.AddMonths(-12).ToRelativeTimeString(date));
            Assert.AreEqual("1 year ago", date.AddYears(-1).ToRelativeTimeString(date));
            Assert.AreEqual("3 years ago", date.AddYears(-3).ToRelativeTimeString(date));

            Assert.AreEqual("1 second from now", date.AddSeconds(1).ToRelativeTimeString(date));
            Assert.AreEqual("10 seconds from now", date.AddSeconds(10).ToRelativeTimeString(date));
            Assert.AreEqual("1 minute from now", date.AddSeconds(90).ToRelativeTimeString(date));
            Assert.AreEqual("1 minute from now", date.AddSeconds(100).ToRelativeTimeString(date));
            Assert.AreEqual("2 minutes from now", date.AddSeconds(120).ToRelativeTimeString(date));
            Assert.AreEqual("7 minutes from now", date.AddMinutes(7).ToRelativeTimeString(date));
            Assert.AreEqual("59 minutes from now", date.AddMinutes(59).ToRelativeTimeString(date));
            Assert.AreEqual("1 hour from now", date.AddMinutes(60).ToRelativeTimeString(date));
            Assert.AreEqual("1 hour from now", date.AddHours(1).ToRelativeTimeString(date));
            Assert.AreEqual("9 hours from now", date.AddHours(9).ToRelativeTimeString(date));
            Assert.AreEqual("1 day from now", date.AddDays(1).ToRelativeTimeString(date));
            Assert.AreEqual("1 day from now", date.AddHours(24).ToRelativeTimeString(date));
            Assert.AreEqual("12 days from now", date.AddDays(12).ToRelativeTimeString(date));
            Assert.AreEqual("29 days from now", date.AddDays(29).ToRelativeTimeString(date));
            Assert.AreEqual("1 month from now", date.AddDays(30).ToRelativeTimeString(date));
            Assert.AreEqual("1 month from now", date.AddMonths(1).ToRelativeTimeString(date));
            Assert.AreEqual("3 months from now", date.AddMonths(3).ToRelativeTimeString(date));
            Assert.AreEqual("11 months from now", date.AddMonths(11).ToRelativeTimeString(date));
            Assert.AreEqual("1 year from now", date.AddMonths(12).ToRelativeTimeString(date));
            Assert.AreEqual("1 year from now", date.AddYears(1).ToRelativeTimeString(date));
            Assert.AreEqual("3 years from now", date.AddYears(3).ToRelativeTimeString(date));
        }
        public void When_date_is_more_than_the_required_one_day_before_another_it_should_not_throw()
        {
            //-----------------------------------------------------------------------------------------------------------
            // Arrange
            //-----------------------------------------------------------------------------------------------------------
            var target = new DateTimeOffset(2.October(2009));
            DateTimeOffset subject = target.AddHours(-25);

            //-----------------------------------------------------------------------------------------------------------
            // Act / Assert
            //-----------------------------------------------------------------------------------------------------------
            subject.Should().BeMoreThan(TimeSpan.FromDays(1)).Before(target);
        }
        public void When_date_is_within_1d_before_another_date_it_should_not_throw()
        {
            //-----------------------------------------------------------------------------------------------------------
            // Arrange
            //-----------------------------------------------------------------------------------------------------------
            var target = new DateTimeOffset(10.April(2010));
            DateTimeOffset subject = target.AddHours(-23);

            //-----------------------------------------------------------------------------------------------------------
            // Act / Assert
            //-----------------------------------------------------------------------------------------------------------
            subject.Should().BeWithin(TimeSpan.FromHours(24)).Before(target);
        }