/// <summary> /// Asserts that a <see cref="DateTimeOffset"/> occurs a specified amount of time before another <see cref="DateTimeOffset"/>. /// </summary> /// <param name="target"> /// The <see cref="DateTimeOffset"/> to compare the subject with. /// </param> /// <param name="because"> /// A formatted phrase explaining why the assertion should be satisfied. If the phrase does not /// start with the word <i>because</i>, it is prepended to the message. /// </param> /// <param name="reasonArgs"> /// Zero or more values to use for filling in any <see cref="string.Format(string,object[])"/> compatible placeholders. /// </param> public AndConstraint<DateTimeOffsetAssertions> Before(DateTimeOffset target, string because = "", params object[] reasonArgs) { bool success = Execute.Assertion .ForCondition(subject.HasValue) .BecauseOf(because, reasonArgs) .FailWith("Expected date and/or time {0} to be " + predicate.DisplayText + " {1} before {2}{reason}, but found a <null> DateTime.", subject, timeSpan, target); if (success) { var actual = target.Subtract(subject.Value); if (!predicate.IsMatchedBy(actual, timeSpan)) { Execute.Assertion .BecauseOf(because, reasonArgs) .FailWith( "Expected date and/or time {0} to be " + predicate.DisplayText + " {1} before {2}{reason}, but it differs {3}.", subject, timeSpan, target, actual); } } return new AndConstraint<DateTimeOffsetAssertions>(parentAssertions); }
public void AdvanceTo(DateTimeOffset when) { if (when < _now) throw new InvalidOperationException("You can't reverse time..."); Advance(when.Subtract(_now)); }
public static void TestTimeSpan() { DateTimeOffset dt = new DateTimeOffset(new DateTime(2012, 6, 18, 10, 5, 1, 0)); TimeSpan ts = dt.TimeOfDay; DateTimeOffset newDate = dt.Subtract(ts); Assert.Equal(new DateTimeOffset(new DateTime(2012, 6, 18, 0, 0, 0, 0)).Ticks, newDate.Ticks); Assert.Equal(dt.Ticks, newDate.Add(ts).Ticks); }
public DateTimeOffset ScheduleNextTime(DateTimeOffset currentTime, JobExecutionRecord lastExecution) { var next = currentTime.Subtract(new TimeSpan(0, 0, 0, currentTime.Second, currentTime.Millisecond)); while (next < currentTime) { next = next.Add(_seconds.Seconds()); } return next; }
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()); }
public Task DeliverAfter(NimbusMessage message, DateTimeOffset deliveryTime) { // Deliberately not awaiting this task. We want it to run in the background. Task.Run(async () => { var delay = deliveryTime.Subtract(_clock.UtcNow); if (delay < TimeSpan.Zero) delay = TimeSpan.Zero; await Task.Delay(delay); AsyncBlockingCollection<NimbusMessage> queue; if (!_messageStore.TryGetExistingMessageQueue(message.DeliverTo, out queue)) return; await queue.Add(message); }).ConfigureAwaitFalse(); return Task.Delay(0); }
public Task DeliverAfter(NimbusMessage message, DateTimeOffset deliveryTime) { _logger.Debug("Enqueuing {MessageId} for re-delivery at {DeliverAt}", message.MessageId, deliveryTime); // Deliberately not awaiting this task. We want it to run in the background. Task.Run(async () => { var delay = deliveryTime.Subtract(_clock.UtcNow); if (delay < TimeSpan.Zero) delay = TimeSpan.Zero; await Task.Delay(delay); _logger.Debug("Re-delivering {MessageId} (attempt {Attempt})", message.MessageId, message.DeliveryAttempts.Length); var sender = _transport.GetQueueSender(message.DeliverTo); await sender.Send(message); }).ConfigureAwaitFalse(); return Task.Delay(0); }
//public void RequestHistoricalData(Security security, DateTime endDateTime, TimeSpan duration, // BarSize barSizeSetting, HistoricalDataType whatToShow, int useRth) //{ // DateTime beginDateTime = endDateTime.Subtract(duration); // string dur = ConvertPeriodtoIb(beginDateTime, endDateTime); // RequestHistoricalData(tickerId, contract, endDateTime, dur, barSizeSetting, whatToShow, useRth); //} /// <summary> /// used for reqHistoricalData /// </summary> private static string ConvertPeriodtoIb(DateTimeOffset startTime, DateTimeOffset endTime) { var period = endTime.Subtract(startTime); var secs = period.TotalSeconds; long unit; if (secs < 1) throw new ArgumentOutOfRangeException("endTime", "Period cannot be less than 1 second."); if (secs < 86400) { unit = (long)Math.Ceiling(secs); return unit + " S"; } var days = secs / 86400; unit = (long)Math.Ceiling(days); if (unit <= 34) return unit + " D"; var weeks = days / 7; unit = (long)Math.Ceiling(weeks); if (unit > 52) throw new ArgumentOutOfRangeException("endTime", "Period cannot be bigger than 52 weeks."); return unit + " W"; }
public void SendSession(DateTimeOffset start, DateTimeOffset end, int sessionId, Guid version) { //TODO: errors at this level should be treated as critical DateTime utcActualStart = start.Subtract(Settings.SessionWarmUp).UtcDateTime; _logger.InfoFormat("Sending StartSessionRequest with SessionId: {0} Version: {1} Start(UTC): {2}", version, sessionId, utcActualStart); StartSessionRequest startRequest = new StartSessionRequest { Version = version, SessionId = sessionId}; Send(startRequest, utcActualStart); DateTime utcActualEnd = end.Add(Settings.SessionCoolDown).UtcDateTime; _logger.InfoFormat("Sending EndSessionRequest with SessionId: {0} Version: {1} End(UTC): {2}", version, sessionId, utcActualEnd); EndSessionRequest endRequest = new EndSessionRequest { Version = version, SessionId = sessionId }; Send(endRequest, utcActualEnd); }
/// <summary> /// Gets the statistical information /// </summary> /// <param name="totalCasesNum">The number of total cases</param> /// <param name="passedNum">The number of passed cases</param> /// <param name="failedNum">The number of failed cases</param> /// <param name="testRunStartTime">The start time of the run</param> /// <param name="testRunEndTime">The end time of the run</param> /// <returns>Return statistical information about this test</returns> public string SummaryTable(long totalCasesNum, long passedNum, long failedNum, DateTimeOffset testRunStartTime, DateTimeOffset testRunEndTime) { DataType.RunSummary sry = new DataType.RunSummary() { TotalCount = totalCasesNum, FailedCount = failedNum, PassedCount = passedNum, InconclusiveCount = totalCasesNum - passedNum - failedNum, PassRate = totalCasesNum == 0 ? 0 : (float)passedNum * 100 / totalCasesNum, StartTime = testRunStartTime.ToLocalTime().ToString("MM/dd/yyyy HH:mm:ss"), EndTime = testRunEndTime.ToLocalTime().ToString("MM/dd/yyyy HH:mm:ss"), Duration = testRunEndTime.Subtract(testRunStartTime).ToString(@"hh\:mm\:ss") }; return (serializer.Serialize(sry)); }
public static void Subtract_DateTimeOffset(DateTimeOffset dt1, DateTimeOffset dt2, TimeSpan expected) { Assert.Equal(expected, dt1 - dt2); Assert.Equal(expected, dt1.Subtract(dt2)); }
public static void Subtract_TimeSpan(DateTimeOffset dt, TimeSpan ts, DateTimeOffset expected) { Assert.Equal(expected, dt - ts); Assert.Equal(expected, dt.Subtract(ts)); }
public static long ToUnixTimeStamp(DateTimeOffset dateTime) { var ts = dateTime.Subtract(new DateTime(1970, 1, 1)).TotalSeconds; return (long)ts; }
private DateTimeOffset CleanOffset(DateTimeOffset offset) { offset = offset.Subtract(TimeSpan.FromMilliseconds(offset.Millisecond)); return offset.Subtract(TimeSpan.FromSeconds(offset.Second)); }
public static void TestOperators() { DateTimeOffset date1 = new DateTimeOffset(new DateTime(1996, 6, 3, 22, 15, 0, DateTimeKind.Utc)); DateTimeOffset date2 = new DateTimeOffset(new DateTime(1996, 12, 6, 13, 2, 0, DateTimeKind.Utc)); DateTimeOffset date3 = new DateTimeOffset(new DateTime(1996, 10, 12, 8, 42, 0, DateTimeKind.Utc)); // diff1 gets 185 days, 14 hours, and 47 minutes. TimeSpan diff1 = date2.Subtract(date1); Assert.Equal(new TimeSpan(185, 14, 47, 0), diff1); // date4 gets 4/9/1996 5:55:00 PM. DateTimeOffset date4 = date3.Subtract(diff1); Assert.Equal(new DateTimeOffset(new DateTime(1996, 4, 9, 17, 55, 0, DateTimeKind.Utc)), date4); // diff2 gets 55 days 4 hours and 20 minutes. TimeSpan diff2 = date2 - date3; Assert.Equal(new TimeSpan(55, 4, 20, 0), diff2); // date5 gets 4/9/1996 5:55:00 PM. DateTimeOffset date5 = date1 - diff2; Assert.Equal(new DateTimeOffset(new DateTime(1996, 4, 9, 17, 55, 0, DateTimeKind.Utc)), date5); }
public async Task ExecuteWithCache_WhenValueIsCachedAndAgeEntryIsTooOldWithAttributes_ShouldAddNewEntry( [Frozen] Mock<ICacheEntryRepository> cacheEntryRepo, CacheService sut, string key, TestCacheReturnValue expected, TestCacheReturnValue notExpected, DateTimeOffset now, Guid id, Dictionary<string, string> attributes) { //arrange cacheEntryRepo.Setup(c => c.Get<TestCacheReturnValue>(It.IsAny<CancellationToken>(), key, attributes)) .ReturnsTask(new CacheEntry<TestCacheReturnValue>( id, key, new Dictionary<string, string>(), now.Subtract(TimeSpan.FromMinutes(10)), notExpected)); cacheEntryRepo.Setup(c => c.AddOrUpdate(CancellationToken.None, It.Is<CacheEntry<TestCacheReturnValue>>(entry => entry.CacheKey == key && entry.Value == expected && entry.Attributes == attributes))) .ReturnsDefaultTask() .Verifiable(); //act await sut.ExecuteWithCache(CancellationToken.None, key, () => Task.FromResult(expected), TimeSpan.FromMinutes(5), attributes); //assert cacheEntryRepo.Verify(); }
public async Task UserLockedOutWithDateTimeNowPlus30() { var db = UnitTestHelper.CreateDefaultDb(); var mgr = TestUtil.CreateManager(db); mgr.UserLockoutEnabledByDefault = true; var user = new IdentityUser("LockoutTest"); UnitTestHelper.IsSuccess(mgr.Create(user)); Assert.True(mgr.GetLockoutEnabled(user.Id)); Assert.True(user.LockoutEnabled); var lockoutEnd = new DateTimeOffset(DateTime.Now.AddMinutes(30)); UnitTestHelper.IsSuccess(await mgr.SetLockoutEndDateAsync(user.Id, lockoutEnd)); // Create a new db to ensure the user entities are recreated db = new IdentityDbContext(); mgr = TestUtil.CreateManager(db); Assert.True(await mgr.IsLockedOutAsync(user.Id)); var end = await mgr.GetLockoutEndDateAsync(user.Id); Assert.True(lockoutEnd.Subtract(end) < TimeSpan.FromSeconds(1)); // Conversions are slightly lossy }
private bool CanRemoveMessage(IMessageViewModel message) { if (message == null) return false; var currentDate = new DateTimeOffset(_mainViewModel.CurrentDateTime); double minutesLeft = currentDate.Subtract(message.SentDate).TotalMinutes; return (message.User.Id == _mainViewModel.CurrentUser.Id && minutesLeft < 10); }
/// <summary> /// Gets the difference between the given <see cref="DateTimeOffset"/> object /// defined by <paramref name="dateTimeOffset"/> and <see cref="UtcNow"/>. /// </summary> /// <param name="dateTimeOffset"> /// The date time offset to be compared with. /// </param> /// <returns> /// The number of seconds difference between the <see cref="DateTimeOffset"/> object and /// <see cref="UtcNow"/>. Zero, if they reference the same point of time; /// greater than zero if the <see cref="DateTimeOffset"/> object in the future, /// or less than zero if the <see cref="DateTimeOffset"/> object is in the past. /// </returns> public int GetDiffereceInSeconds(DateTimeOffset dateTimeOffset) { return Convert.ToInt32(dateTimeOffset.Subtract(this.UtcNow).TotalSeconds); }
/// <summary> /// (Re)sets the process delayed actions timer to trigger based on the given due time. /// </summary> /// <param name="nextDueTime">Time when the timer should timeout.</param> private void ResetProcessDelayedActionsTimer(DateTimeOffset nextDueTime) { if (_processDelayedActionsTimer != null) { _processDelayedActionsTimer.Dispose(); } int millisecondsToNextProcessingOfDelayedActions = (int)nextDueTime.Subtract(DateTimeOffset.Now).TotalMilliseconds; System.Diagnostics.Debug.WriteLine("SDKManager.ResetProcessDelayedActionsTimer(): " + Math.Round((double)millisecondsToNextProcessingOfDelayedActions / 1000, 0) + " second(s) to next processing of delayed actions"); _processDelayedActionsTimer = new Timer(OnProcessDelayedActionsTimerTimeoutAsync, null, millisecondsToNextProcessingOfDelayedActions, Timeout.Infinite); }
/// <summary> /// </summary> /// <param name="key"></param> /// <param name="value"></param> /// <param name="absoluteExpiration"></param> /// <returns> /// <c>true</c> if insertion succeeded, or <c>false</c> if there is an already an entry in the cache that has the same key as key. /// </returns> /// <exception cref="NotImplementedException"></exception> public bool Add(string key, ICacheItem value, DateTimeOffset absoluteExpiration) { if (key == null) throw new ArgumentNullException("key"); try { if (IsCacheInitilized()) { TimeSpan expiration = absoluteExpiration.Subtract(DateTimeOffset.UtcNow); this.cache.SetAsync(key, value, expiration); double expirationInSeconds = Math.Ceiling(expiration.TotalSeconds); Trace.TraceInformation("Redis Cache Provider: Requested to add asyn key {0} for {1} secounds. Correlation Id = {2}", key, expirationInSeconds, Trace.CorrelationManager.ActivityId); return true; } else { Trace.TraceWarning("Redis Cache Provider: Cache still not initilized when trying to add the key {0}. Correlation Id = {1}", key, Trace.CorrelationManager.ActivityId); } } catch (Exception ex) { Trace.TraceError("Redis Cache Provider: Error inserting cache item. Key={0}, Correlation Id = {2}.\n Exception Message {3}\n{4}", key, Trace.CorrelationManager.ActivityId, ex.Message, ex.StackTrace); } return false; }
public static void ForwardTimeUntil(DateTimeOffset startTime, DateTimeOffset dateTime, TimeSpan timeout) { var dueTime = GetDueTime(dateTime.Subtract(startTime)); WaitOnTimer(dueTime, timeout); }
public static void IsNear(DateTimeOffset expected, DateTimeOffset actual, TimeSpan threshold) { IsWithinThreshold(expected.Subtract(actual), threshold); }
public async Task ExecuteWithCache_WhenValueIsCachedAndAgeEntryIsTooOld_ShouldRemoveOldEntry( [Frozen] Mock<ICacheEntryRepository> cacheEntryRepo, CacheService sut, string key, TestCacheReturnValue expected, TestCacheReturnValue notExpected, DateTimeOffset now, Guid id) { //arrange cacheEntryRepo.Setup(c => c.Get<TestCacheReturnValue>(It.IsAny<CancellationToken>(), key, It.Is<IDictionary<string, string>>(d => d.Count == 0))) .ReturnsTask(new CacheEntry<TestCacheReturnValue>( id, key, new Dictionary<string, string>(), now.Subtract(TimeSpan.FromMinutes(10)), notExpected)); //act await sut.ExecuteWithCache(CancellationToken.None, key, () => Task.FromResult(expected), TimeSpan.FromMinutes(5)); //assert cacheEntryRepo.Verify(c => c.Remove<TestCacheReturnValue>(CancellationToken.None, key, id)); }
/// <summary> /// Returns a <see cref="DateTimeOffset"/> which subtract current <see cref="TimeSpan"/> ago from the <paramref name="time"/>. /// </summary> /// <param name="source">A <see cref="TimeSpan"/> instance.</param> /// <param name="time">A <see cref="DateTimeOffset"/> ago from.</param> /// <returns>Returns a <see cref="DateTimeOffset"/> which subtract current <see cref="TimeSpan"/> ago from the <paramref name="time"/>.</returns> public static DateTimeOffset Until(this TimeSpan source, DateTimeOffset time) { return time.Subtract(source); }
public async Task Invalidate_WithIsYoungerThanMinAge_ShouldNotRemoveCacheEntry( [Frozen] Mock<ICacheEntryRepository> cacheEntryRepo, CacheService sut, string key, TestCacheReturnValue value, DateTimeOffset now) { //arrange var entry = new CacheEntry<TestCacheReturnValue>(Guid.NewGuid(), key, new Dictionary<string, string>(), now.Subtract(TimeSpan.FromMinutes(2)), value); cacheEntryRepo.Setup(c => c.Get<TestCacheReturnValue>(It.IsAny<CancellationToken>(), key, It.Is<IDictionary<string, string>>(d => d.Count == 0))) .ReturnsTask(entry); //act await sut.Invalidate<TestCacheReturnValue>(CancellationToken.None, key, TimeSpan.FromMinutes(2)); //assert cacheEntryRepo.Verify(c => c.Remove<TestCacheReturnValue>(It.IsAny<CancellationToken>(), key, entry.Id), Times.Never()); }
public static void AddSubtract_TimeSpan() { var dateTimeOffset = new DateTimeOffset(new DateTime(2012, 6, 18, 10, 5, 1, 0, DateTimeKind.Utc)); TimeSpan timeSpan = dateTimeOffset.TimeOfDay; DateTimeOffset newDate = dateTimeOffset.Subtract(timeSpan); Assert.Equal(new DateTimeOffset(new DateTime(2012, 6, 18, 0, 0, 0, 0, DateTimeKind.Utc)).Ticks, newDate.Ticks); Assert.Equal(dateTimeOffset.Ticks, newDate.Add(timeSpan).Ticks); }
//Use this method in LINQ queries when using constant DateTimeOffset value, when your target database is SQL CE public static DateTimeOffset AdjustDateTimeOffsetForLinq(DateTimeOffset value) { AdjustDefaultDateTimeFormatForSqlCe(); return value.Subtract(value.Offset); }
public static void IsAfter(DateTimeOffset expected, DateTimeOffset actual) { TimeSpan difference = actual.Subtract(expected); Assert.IsTrue(difference.Ticks > 0); }
public int CheckForAvailableResources(int subscriptionId, DateTimeOffset sessionStart, DateTimeOffset sessionEnd) { int availableCPUs; using (ApplicationDbContext context = new ApplicationDbContext()) { //TODO: move warmUP and coolDown into the config TimeSpan warmUp = new TimeSpan(0, 20, 0); //there is an extra +5 as this is a safe assumption as how long will it take for azure to //delete the VMs TimeSpan coolDown = new TimeSpan(0, 30 + 5, 0); DateTimeOffset start = sessionStart.Subtract(warmUp); DateTimeOffset end = sessionEnd.Add(coolDown); var sameWindowSessions = context.Sessions.Where(x => x.SubscriptionId == subscriptionId && x.StartDate <= end && x.EndDate >= start && !x.Removed).ToList(); //int projectedCPUs = sameWindowSessions.Sum(x => Sessions.CalculateSessionCPUs(x)); int projectedCPUs = MaxOverlappingCPUs(sameWindowSessions); //now check how many VMs programmed are running at the moment List<VmSizeEnum> runningVMs = context.VirtualMachines .Where(x => !x.Deleted && !x.Stopped && x.Session.SubscriptionId == subscriptionId) .Select(x => x.Session.VmSize).ToList() .Select(x => (VmSizeEnum)Enum.Parse(typeof(VmSizeEnum), x)).ToList(); int currentPlannedCPUs = runningVMs.Sum(x => (int)x); Subscription subscription = context.Subscriptions .Single(x => x.SubscriptionId == subscriptionId); IVMManagement management = AzureFacadeFactory.VMManagement(subscription.AzureSubscriptionId, subscription.Certificate, subscription.CertificateKey, subscription.BlobStorageName, subscription.BlobStorageKey); SubscriptionDetails subscriptionDetails = management.GetSubscriptionDetails(); int unknownCPUs = subscriptionDetails.MaxCoreCount - subscriptionDetails.AvailableCoreCount - currentPlannedCPUs; unknownCPUs = Math.Max(unknownCPUs, 0); availableCPUs = subscriptionDetails.MaxCoreCount - unknownCPUs - projectedCPUs; } return availableCPUs; }