// ReSharper disable once SuggestBaseTypeForParameter public PendingDirectory(InstallationDirectory installationDirectory, SystemClock clock) { _pendingLocation = installationDirectory.GetChildDirectory(LocationExtensions.Pending); _pendingLocation.EnsureExists(); _clock = clock; }
public TuckerRockyGatherShipmentsHandler(IDropShipper dropShipper, ITuckerRockyClient client, SystemClock clock, TuckerRockyConfig config) { _dropShipper = dropShipper; _client = client; _clock = clock; _config = config; }
/// <summary> /// The full and original text of the command. /// </summary> /// <param name="commandText">The command text.</param> /// <param name="transactionList">The transaction list.</param> /// <param name="siteList"></param> /// <param name="systemClock"></param> public BaseAction(string commandText, TransactionList transactionList, SiteList siteList, SystemClock systemClock) { CommandText = commandText; TransactionList = transactionList; SiteList = siteList; systemClock = systemClock; }
/// <summary> /// Initializes a new instance of the <see cref="Site"/> class. /// </summary> /// <param name='siteId'> /// Site identifier. /// </param> public Site(int siteId, SiteList siteList, SystemClock systemClock) { Id = siteId; VariableList = new List<Variable>(); SiteList = siteList; FailTimes = new List<FailureRecoverPair>(); SystemClock = systemClock; IsFailed = false; }
public Dump(string commandText, TransactionList transactionList, SiteList siteList, SystemClock systemClock) : base(commandText, transactionList, siteList, systemClock) { string[] info = commandText.Split(new[] { '(', ')' }); DumpFull = info[1].Trim().Equals(String.Empty); if (info.Count() == 3) DumpObject = info[1]; }
static void Main() { // set the clock and mailing component to be used IClock clock = new SystemClock(); IMailer mailer = new MailerStub(); Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new AdminForm(clock, mailer)); }
/// <summary> /// Creates an instance of bearer authentication options with default values. /// </summary> public OAuthBearerAuthenticationOptions() : base() { AuthenticationScheme = OAuthBearerAuthenticationDefaults.AuthenticationScheme; BackchannelTimeout = TimeSpan.FromMinutes(1); Challenge = OAuthBearerAuthenticationDefaults.AuthenticationScheme; Notifications = new OAuthBearerAuthenticationNotifications(); RefreshOnIssuerKeyNotFound = true; SystemClock = new SystemClock(); TokenValidationParameters = new TokenValidationParameters(); }
/// <summary> /// Initializes a new instance of the <see cref="Transaction"/> class. /// </summary> /// <param name="transactionId">The transaction id.</param> /// <param name="systemClock">The system clock.</param> public Transaction(string transactionId, SystemClock systemClock) { Id = transactionId; Status = TransactionStatus.Created; LocksHeld = new List<Site>(); QueuedCommands = new Queue<BaseAction>(); AwaitingReReplication = new List<ValueSitePair>(); SiteUsedList= new List<SiteAccessRecord>(); SystemClock = systemClock; }
static void Main() { // define the clock, database, and mailing component to be used IClock clock = new SystemClock(); IMailer mailer = new MailerStub(); ParkingDatabase database = new ParkingDatabase(clock, mailer); Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new UserForm(clock, mailer, database, false)); }
/// <summary> /// Create an instance of the options initialized with the default values /// </summary> public CookieAuthenticationOptions() { AuthenticationScheme = CookieAuthenticationDefaults.AuthenticationScheme; ReturnUrlParameter = CookieAuthenticationDefaults.ReturnUrlParameter; ExpireTimeSpan = TimeSpan.FromDays(14); SlidingExpiration = true; CookieHttpOnly = true; CookieSecure = CookieSecureOption.SameAsRequest; SystemClock = new SystemClock(); Notifications = new CookieAuthenticationNotifications(); }
public Variable(int id, Site site, SystemClock systemClock) { ReadLockHolders = new List<Transaction>(); WriteLockHolder = null; SystemClock = systemClock; Site = site; VariableHistory = new List<VariableValue>(); UncomittedValue = string.Empty; IsReadable = true; Id = id; }
public BeginTransaction(string commandText, TransactionList transactionList, SiteList siteList, SystemClock systemClock) : base(commandText, transactionList, siteList, systemClock) { string[] info = commandText.Split(new[] {'(', ')'}); if (info.Length != 3) throw new Exception("Invalid command format: " + commandText); Transaction = new Transaction(info[1], systemClock) {IsReadOnly = info[0].ToLower().Equals("beginro")}; transactionList.AddTransaction(Transaction); }
public EndTransaction(string commandText, TransactionList transactionList, SiteList siteList, SystemClock systemClock) : base(commandText, transactionList, siteList, systemClock) { string[] info = commandText.Split(new[] {'(', ')'}); if (info.Length != 3) throw new Exception("Invalid command format: " + commandText); Transaction = transactionList.GetTransaction(info[1]); if (Transaction == null) throw new Exception("Transaction not found: " + commandText); }
/// <summary> /// Initializes a new instance of the <see cref="Fail"/> class. /// </summary> /// <param name="commandText">The command text.</param> /// <param name="transactionList">The transaction list.</param> /// <param name="siteList"></param> /// <param name="systemClock"></param> public Fail(string commandText, TransactionList transactionList, SiteList siteList, SystemClock systemClock) : base(commandText, transactionList, siteList, systemClock) { string[] info = commandText.Split(new[] { '(', ')' }); if (info.Length != 3) throw new Exception("Invalid command format: " + commandText); Site = siteList.GetSite(int.Parse(info[1])); if (Site == null) throw new Exception("Site not found:" + info[1]); }
public VendorPusher( Lazy<IItemUpdates<UpdateQuantityHeader, VendorQtyEntry>> inventoryUpdater, IItemUpdates<PriceHeader, VendorPriceEntry> costsUpdater, IReadyDirectory readyDirectory, IFileHelpersCache fileHelpersCache, IArchiveDirectory archiveDirectory, SystemClock systemClock, ILogger logger) { _inventoryUpdater = inventoryUpdater; _readyDirectory = readyDirectory; _fileHelpersCache = fileHelpersCache; _archiveDirectory = archiveDirectory; _systemClock = systemClock; _logger = logger; _costsUpdater = costsUpdater; }
private void When_changing_directory_last_write_time_in_local_zone_it_must_refresh_automatically() { // Arrange const string path = @"c:\some\folder"; var clock = new SystemClock(() => DefaultTimeUtc); IFileSystem fileSystem = new FakeFileSystemBuilder(clock) .IncludingDirectory(path) .Build(); IDirectoryInfo dirInfo = fileSystem.ConstructDirectoryInfo(path); DateTime beforeTime = dirInfo.LastWriteTime; // Act dirInfo.LastWriteTime = AlternateTime; // Assert DateTime afterTime = dirInfo.LastWriteTime; beforeTime.Should().Be(DefaultTime); afterTime.Should().Be(AlternateTime); }
public virtual async Task CanGetBufferedQueueMetricsAsync() { using var metrics = GetMetricsClient(true) as IBufferedMetricsClient; if (metrics is not IMetricsClientStats stats) { return; } using var behavior = new MetricsQueueBehavior <SimpleWorkItem>(metrics, reportCountsInterval: TimeSpan.FromMilliseconds(25), loggerFactory: Log); using var queue = new InMemoryQueue <SimpleWorkItem>(new InMemoryQueueOptions <SimpleWorkItem> { Behaviors = new[] { behavior }, LoggerFactory = Log }); await queue.EnqueueAsync(new SimpleWorkItem { Id = 1, Data = "1" }); await SystemClock.SleepAsync(50); var entry = await queue.DequeueAsync(TimeSpan.Zero); await SystemClock.SleepAsync(15); await entry.CompleteAsync(); await SystemClock.SleepAsync(100); // give queue metrics time await metrics.FlushAsync(); var queueStats = await stats.GetQueueStatsAsync("simpleworkitem"); Assert.Equal(1, queueStats.Count.Max); Assert.Equal(0, queueStats.Count.Last); Assert.Equal(1, queueStats.Enqueued.Count); Assert.Equal(1, queueStats.Dequeued.Count); Assert.Equal(1, queueStats.Completed.Count); Assert.InRange(queueStats.QueueTime.AverageDuration, 45, 250); Assert.InRange(queueStats.ProcessTime.AverageDuration, 10, 250); }
public void Should_call_ontimeout_with_timeout_supplied_different_for_each_execution_by_evaluating_func_influenced_by_context__optimistic(int programaticallyControlledDelay) { Func <Context, TimeSpan> timeoutProvider = ctx => (TimeSpan)ctx["timeout"]; TimeSpan?timeoutPassedToOnTimeout = null; Action <Context, TimeSpan, Task> onTimeout = (ctx, span, task) => { timeoutPassedToOnTimeout = span; }; var policy = Policy.Timeout <ResultPrimitive>(timeoutProvider, TimeoutStrategy.Optimistic, onTimeout); var userCancellationToken = CancellationToken.None; // Supply a programatically-controlled timeout, via the execution context. Context context = new Context("SomeOperationKey") { ["timeout"] = TimeSpan.FromMilliseconds(25 * programaticallyControlledDelay) }; policy.Invoking(p => p.Execute((ctx, ct) => { SystemClock.Sleep(TimeSpan.FromSeconds(3), ct); return(ResultPrimitive.WhateverButTooLate); }, context, userCancellationToken)) .ShouldThrow <TimeoutRejectedException>(); timeoutPassedToOnTimeout.Should().Be(timeoutProvider(context)); }
public virtual async Task CanRunQueueJobWithLockFailAsync() { const int workItemCount = 10; const int allowedLockCount = 5; Log.SetLogLevel <ThrottlingLockProvider>(LogLevel.Trace); using (var queue = GetSampleWorkItemQueue(retries: 3, retryDelay: TimeSpan.Zero)) { await queue.DeleteQueueAsync(); var enqueueTask = Run.InParallelAsync(workItemCount, index => { _logger.LogInformation($"Enqueue #{index}"); return(queue.EnqueueAsync(new SampleQueueWorkItem { Created = SystemClock.UtcNow, Path = "somepath" + index })); }); var lockProvider = new ThrottlingLockProvider(new InMemoryCacheClient(new InMemoryCacheClientOptions()), allowedLockCount, TimeSpan.FromDays(1), Log); var job = new SampleQueueJobWithLocking(queue, null, lockProvider, Log); await SystemClock.SleepAsync(10); _logger.LogInformation("Starting RunUntilEmptyAsync"); await Task.WhenAll(job.RunUntilEmptyAsync(), enqueueTask); _logger.LogInformation("Done RunUntilEmptyAsync"); var stats = await queue.GetQueueStatsAsync(); Assert.Equal(0, stats.Queued); Assert.Equal(workItemCount, stats.Enqueued); Assert.Equal(allowedLockCount, stats.Completed); Assert.Equal(allowedLockCount * 4, stats.Abandoned); Assert.Equal(allowedLockCount, stats.Deadletter); } }
private void When_changing_file_creation_time_in_UTC_it_must_refresh_automatically() { // Arrange const string path = @"c:\some\file.txt"; var clock = new SystemClock(() => DefaultTimeUtc); IFileSystem fileSystem = new FakeFileSystemBuilder(clock) .IncludingEmptyFile(path) .Build(); IFileInfo fileInfo = fileSystem.ConstructFileInfo(path); DateTime beforeTime = fileInfo.CreationTimeUtc; // Act fileInfo.CreationTimeUtc = AlternateTimeUtc; // Assert DateTime afterTime = fileInfo.CreationTimeUtc; beforeTime.Should().Be(DefaultTimeUtc); afterTime.Should().Be(AlternateTimeUtc); }
private async Task CleanupSoftDeletedOrganizationsAsync(JobContext context) { var organizationResults = await _organizationRepository.GetAllAsync(q => q.SoftDeleteMode(SoftDeleteQueryMode.DeletedOnly).SnapshotPaging().PageLimit(5)).AnyContext(); _logger.CleanupOrganizationSoftDeletes(organizationResults.Total); while (organizationResults.Documents.Count > 0 && !context.CancellationToken.IsCancellationRequested) { foreach (var organization in organizationResults.Documents) { using (_logger.BeginScope(new ExceptionlessState().Organization(organization.Id))) { await RemoveOrganizationAsync(organization, context).AnyContext(); // Sleep so we are not hammering the backend. await SystemClock.SleepAsync(TimeSpan.FromSeconds(5)).AnyContext(); } } if (context.CancellationToken.IsCancellationRequested || !await organizationResults.NextPageAsync().AnyContext()) { break; } } }
public void Should_be_able_to_cancel_with_user_cancellation_token_before_timeout__optimistic() { Stopwatch watch = new Stopwatch(); int timeout = 10; var policy = Policy.Timeout(timeout, TimeoutStrategy.Optimistic); TimeSpan tolerance = TimeSpan.FromSeconds(3); // Consider increasing tolerance, if test fails transiently in different test/build environments. TimeSpan userTokenExpiry = TimeSpan.FromSeconds(1); // Use of time-based token irrelevant to timeout policy; we just need some user token that cancels independently of policy's internal token. using (CancellationTokenSource userTokenSource = new CancellationTokenSource(userTokenExpiry)) { watch.Start(); policy.Invoking(p => p.Execute( ct => SystemClock.Sleep(TimeSpan.FromSeconds(timeout), ct) // Simulate cancel in the middle of execution , userTokenSource.Token) // ... with user token. ).ShouldThrow <OperationCanceledException>(); watch.Stop(); } watch.Elapsed.Should().BeLessThan(TimeSpan.FromSeconds(timeout * 0.8)); watch.Elapsed.Should().BeCloseTo(userTokenExpiry, ((int)tolerance.TotalMilliseconds)); }
private void When_updating_directory_attributes_it_must_not_update_directory_timings() { // Arrange const string path = @"C:\folder"; DateTime creationTimeUtc = 17.March(2006).At(14, 03, 53).AsUtc(); var clock = new SystemClock(() => creationTimeUtc); IFileSystem fileSystem = new FakeFileSystemBuilder(clock) .IncludingDirectory(path) .Build(); DateTime updateTimeUtc = 18.March(2006).At(14, 03, 53).AsUtc(); clock.UtcNow = () => updateTimeUtc; // Act fileSystem.File.SetAttributes(path, FileAttributes.Directory | FileAttributes.Hidden); // Assert fileSystem.Directory.GetCreationTimeUtc(path).Should().Be(creationTimeUtc); fileSystem.Directory.GetLastWriteTimeUtc(path).Should().Be(creationTimeUtc); fileSystem.Directory.GetLastAccessTimeUtc(path).Should().Be(creationTimeUtc); }
public virtual async Task WorkItemsWillTimeoutAsync() { var queue = GetQueue(retryDelay: TimeSpan.Zero, workItemTimeout: TimeSpan.FromMilliseconds(50)); if (queue == null) { return; } using (queue) { await queue.DeleteQueueAsync(); await AssertEmptyQueueAsync(queue); await queue.EnqueueAsync(new SimpleWorkItem { Data = "Hello" }); var workItem = await queue.DequeueAsync(TimeSpan.Zero); Assert.NotNull(workItem); Assert.Equal("Hello", workItem.Value.Data); await SystemClock.SleepAsync(TimeSpan.FromSeconds(1)); // wait for the task to be auto abandoned var sw = Stopwatch.StartNew(); workItem = await queue.DequeueAsync(TimeSpan.FromSeconds(5)); sw.Stop(); _logger.Trace("Time {0}", sw.Elapsed); Assert.NotNull(workItem); await workItem.CompleteAsync(); Assert.Equal(0, (await queue.GetQueueStatsAsync()).Queued); } }
public virtual async Task CanRunQueueJobAsync() { const int workItemCount = 100; using (var queue = GetSampleWorkItemQueue(retries: 0, retryDelay: TimeSpan.Zero)) { await queue.DeleteQueueAsync(); var enqueueTask = Run.InParallelAsync(workItemCount, index => queue.EnqueueAsync(new SampleQueueWorkItem { Created = SystemClock.UtcNow, Path = "somepath" + index })); var job = new SampleQueueJob(queue, null, Log); await SystemClock.SleepAsync(10); await Task.WhenAll(Task.Run(() => job.RunUntilEmpty()), enqueueTask); var stats = await queue.GetQueueStatsAsync(); Assert.Equal(0, stats.Queued); Assert.Equal(workItemCount, stats.Enqueued); Assert.Equal(workItemCount, stats.Dequeued); } }
private void When_creating_file_it_must_update_file_timings() { // Arrange const string path = @"C:\some\file.txt"; DateTime creationTimeUtc = 17.March(2006).At(14, 03, 53).AsUtc(); var clock = new SystemClock { UtcNow = () => creationTimeUtc }; IFileSystem fileSystem = new FakeFileSystemBuilder(clock) .IncludingDirectory(@"c:\some") .Build(); // Act using (fileSystem.File.Create(path)) { } // Assert fileSystem.File.GetCreationTimeUtc(path).Should().Be(creationTimeUtc); fileSystem.File.GetLastWriteTimeUtc(path).Should().Be(creationTimeUtc); fileSystem.File.GetLastAccessTimeUtc(path).Should().Be(creationTimeUtc); }
public void Should_call_ontimeout_with_timing_out_exception__optimistic() { TimeSpan timeoutPassedToConfiguration = TimeSpan.FromMilliseconds(250); Exception exceptionPassedToOnTimeout = null; Func <Context, TimeSpan, Task, Exception, Task> onTimeoutAsync = (ctx, span, task, exception) => { exceptionPassedToOnTimeout = exception; return(TaskHelper.EmptyTask); }; var policy = Policy.TimeoutAsync <ResultPrimitive>(timeoutPassedToConfiguration, TimeoutStrategy.Optimistic, onTimeoutAsync); var userCancellationToken = CancellationToken.None; policy.Awaiting(async p => await p.ExecuteAsync(async ct => { await SystemClock.SleepAsync(TimeSpan.FromSeconds(3), ct).ConfigureAwait(false); return(ResultPrimitive.WhateverButTooLate); }, userCancellationToken).ConfigureAwait(false)) .Should().Throw <TimeoutRejectedException>(); exceptionPassedToOnTimeout.Should().NotBeNull(); exceptionPassedToOnTimeout.Should().BeOfType(typeof(OperationCanceledException)); }
public void stop(NumberPicker picker, long elapsedTime) { // Execute dummy touch to adjust the position of the picker long now = SystemClock.UptimeMillis(); int touchX = picker.Width / 2; int topTouchY = picker.Height / 5; int bottomTouchY = picker.Height * 4 / 5; const int metaState = 0; // Dummy touch of upper side of the picker MotionEvent e = MotionEvent.Obtain( now, now, MotionEventActions.Down, touchX, topTouchY, metaState); picker.DispatchTouchEvent(e); e.Action = MotionEventActions.Up; picker.DispatchTouchEvent(e); // Dummy touch of bottom side of the picker e = MotionEvent.Obtain( now, now, MotionEventActions.Down, touchX, bottomTouchY, metaState); picker.DispatchTouchEvent(e); e.Action = MotionEventActions.Up; picker.DispatchTouchEvent(e); }
public void AddCategoryToPost([FromBody] AdminCategoryModel model) { var existing = this.db.Categories.Single(c => c.Title == model.Title); if (existing == null) { var newCategory = new Category { ProfileId = GetProfile().Id, Title = model.Title, Description = model.Title, Slug = model.Title.ToSlug(), LastUpdated = SystemClock.Now() }; this.db.Categories.Add(newCategory); this.db.Complete(); existing = this.db.Categories.Single(c => c.Title == model.Title); } this.db.Categories.AddCategoryToPost(int.Parse(model.PostId), existing.Id); this.db.Complete(); }
public void CanSendMultiple() { const int iterations = 100000; StartListening(iterations); var sw = Stopwatch.StartNew(); for (int index = 0; index < iterations; index++) { if (index % (iterations / 10) == 0) { StopListening(); } _client.Counter("counter"); if (index % (iterations / 10) == 0) { StartListening(iterations - index); } } sw.Stop(); // Require at least 10,000 operations/s Assert.InRange(sw.ElapsedMilliseconds, 0, (iterations / 10000.0) * 1000); SystemClock.Sleep(250); var messages = GetMessages(); Assert.InRange(messages.Count, iterations - (iterations / 10), iterations); foreach (string message in messages) { Assert.Equal("test.counter:1|c", message); } }
public async Task CanSleepAsync() { using (TestSystemClock.Install()) { var sw = Stopwatch.StartNew(); await SystemClock.SleepAsync(250); sw.Stop(); Assert.InRange(sw.ElapsedMilliseconds, 225, 3000); SystemClock.Test.UseFakeSleep(); var now = SystemClock.UtcNow; sw.Restart(); await SystemClock.SleepAsync(1000); sw.Stop(); var afterSleepNow = SystemClock.UtcNow; Assert.InRange(sw.ElapsedMilliseconds, 0, 30); Assert.True(afterSleepNow > now); Assert.InRange(afterSleepNow.Subtract(now).TotalMilliseconds, 950, 5000); } }
private void When_creating_file_it_must_update_directory_timings() { // Arrange const string containerPath = @"C:\folder"; DateTime creationTimeUtc = 17.March(2006).At(14, 03, 53).AsUtc(); var clock = new SystemClock(() => creationTimeUtc); IFileSystem fileSystem = new FakeFileSystemBuilder(clock) .IncludingDirectory(containerPath) .Build(); DateTime updateTimeUtc = 18.March(2006).At(14, 03, 53).AsUtc(); clock.UtcNow = () => updateTimeUtc; // Act fileSystem.File.WriteAllText(@"c:\folder\file.txt", "X"); // Assert fileSystem.Directory.GetCreationTimeUtc(containerPath).Should().Be(creationTimeUtc); fileSystem.Directory.GetLastWriteTimeUtc(containerPath).Should().Be(updateTimeUtc); fileSystem.Directory.GetLastAccessTimeUtc(containerPath).Should().Be(updateTimeUtc); }
private void prepareTracking(int position) { mTracking = true; mVelocityTracker = VelocityTracker.Obtain(); Boolean opening = !mExpanded; if (opening) { mAnimatedAcceleration = mMaximumAcceleration; mAnimatedVelocity = mMaximumMajorVelocity; if (mInvert) { mAnimationPosition = mTopOffset; } else { mAnimationPosition = mBottomOffset + (mVertical ? Height - mHandleHeight : Width - mHandleWidth); } moveHandle((int)mAnimationPosition); mAnimating = true; mHandler.RemoveMessages(MSG_ANIMATE); long now = SystemClock.UptimeMillis(); mAnimationLastTime = now; mCurrentAnimationTime = now + ANIMATION_FRAME_DURATION; mAnimating = true; } else { if (mAnimating) { mAnimating = false; mHandler.RemoveMessages(MSG_ANIMATE); } moveHandle(position); } }
public void Should_not_be_able_to_cancel_with_user_cancellation_token_before_timeout__pessimistic() { Stopwatch watch = new Stopwatch(); int timeout = 5; var policy = Policy.TimeoutAsync(timeout, TimeoutStrategy.Pessimistic); TimeSpan tolerance = TimeSpan.FromSeconds(3); // Consider increasing tolerance, if test fails transiently in different test/build environments. TimeSpan userTokenExpiry = TimeSpan.FromSeconds(1); // Use of time-based token irrelevant to timeout policy; we just need some user token that cancels independently of policy's internal token. using (CancellationTokenSource userTokenSource = new CancellationTokenSource(userTokenExpiry)) { watch.Start(); policy.Awaiting(async p => await p.ExecuteAsync(async _ => { await SystemClock.SleepAsync(TimeSpan.FromSeconds(timeout * 2), CancellationToken.None).ConfigureAwait(false); // Do not observe any cancellation in the middle of execution }, userTokenSource.Token) // ... with user token. ).ShouldThrow <TimeoutRejectedException>(); watch.Stop(); } watch.Elapsed.Should().BeCloseTo(TimeSpan.FromSeconds(timeout), ((int)tolerance.TotalMilliseconds)); }
static void Main(string[] args) { SystemClock oncePerSecond = new SystemClock(); VariableSystemClock oncePerInterval = new VariableSystemClock(TimeSpan.FromSeconds(2)); Console.WriteLine("Start:"); Console.WriteLine(" oncePerSecond: {0}", oncePerSecond.getSystemTime()); Console.WriteLine(" oncePerInterval: {0}", oncePerInterval.getSystemTime()); Console.WriteLine(); for (Int32 i = 0; i < 10; i++) { // sleep three seconds System.Threading.Thread.Sleep(TimeSpan.FromSeconds(2)); // display output Console.WriteLine("Interval {0}:", i); Console.WriteLine(" oncePerSecond: {0}", oncePerSecond.getSystemTime()); Console.WriteLine(" oncePerInterval: {0}", oncePerInterval.getSystemTime()); Console.WriteLine(); } Console.WriteLine("End:"); Console.WriteLine(" oncePerSecond: {0}", oncePerSecond.getSystemTime()); Console.WriteLine(" oncePerInterval: {0}", oncePerInterval.getSystemTime()); Console.WriteLine(); }
async Task SaveStatsTotals(int postId) { try { var existentTotal = _db.StatsTotals.Where(s => s.PostId == postId && s.DateCreated == SystemClock.Now().Date).FirstOrDefault(); if (existentTotal == null) { await _db.StatsTotals.AddAsync(new StatsTotal { PostId = postId, Total = 1, DateCreated = SystemClock.Now().Date }); } else { existentTotal.Total = existentTotal.Total + 1; } await _db.SaveChangesAsync(); } catch { } }
public string receive() { try { string s = ""; int x = 10; while (!s.Contains('\n') && !s.Contains(">")) { #if !disablebluetooth x = _socket.InputStream.Read(buffer, 0, buffer.Length); if (recieveTime < SystemClock.ElapsedRealtime()) { s = ""; } recieveTime = SystemClock.ElapsedRealtime() + 50; s += System.Text.Encoding.ASCII.GetString(buffer, 0, x).Replace('\r', '\n'); } #else /*if (!inputStream.IsDataAvailable()) * inputStream.Seek(0, SeekOrigin.Begin );*/ s += (char)inputStream.ReadByte(); if (createHangup) { while (true) { ; } } } //Thread.Sleep(1); #endif /*#if DEBUG * Console.WriteLine(s); #endif*/ return(s); } catch (Exception) { return(""); }
public void Should_call_ontimeout_with_timeout_supplied_different_for_each_execution_by_evaluating_func__pessimistic() { for (int i = 1; i <= 3; i++) { Func <TimeSpan> timeoutFunc = () => TimeSpan.FromMilliseconds(25 * i); TimeSpan?timeoutPassedToOnTimeout = null; Func <Context, TimeSpan, Task, Task> onTimeoutAsync = (ctx, span, task) => { timeoutPassedToOnTimeout = span; return(TaskHelper.EmptyTask); }; var policy = Policy.TimeoutAsync(timeoutFunc, TimeoutStrategy.Pessimistic, onTimeoutAsync); policy.Awaiting(async p => await p.ExecuteAsync(async() => { await SystemClock.SleepAsync(TimeSpan.FromSeconds(3), CancellationToken.None).ConfigureAwait(false); })) .ShouldThrow <TimeoutRejectedException>(); timeoutPassedToOnTimeout.Should().Be(timeoutFunc()); } }
public virtual async Task CanGetBufferedQueueMetrics() { using (var metrics = GetMetricsClient(true) as IBufferedMetricsClient) { var stats = metrics as IMetricsClientStats; if (stats == null) { return; } using (var queue = new InMemoryQueue <SimpleWorkItem>(behaviors: new[] { new MetricsQueueBehavior <SimpleWorkItem>(metrics, loggerFactory: Log) }, loggerFactory: Log)) { await queue.EnqueueAsync(new SimpleWorkItem { Id = 1, Data = "1" }); await SystemClock.SleepAsync(50); var entry = await queue.DequeueAsync(TimeSpan.Zero); await SystemClock.SleepAsync(30); await entry.CompleteAsync(); await SystemClock.SleepAsync(500); // give queue metrics time await metrics.FlushAsync(); var queueStats = await stats.GetQueueStatsAsync("simpleworkitem"); Assert.Equal(1, queueStats.Count.Max); Assert.Equal(0, queueStats.Count.Last); Assert.Equal(1, queueStats.Enqueued.Count); Assert.Equal(1, queueStats.Dequeued.Count); Assert.Equal(1, queueStats.Completed.Count); Assert.InRange(queueStats.QueueTime.AverageDuration, 50, 200); Assert.InRange(queueStats.ProcessTime.AverageDuration, 30, 200); } } }
public NES() { //clock = new SystemClock(200000); clock = new SystemClock(5369318); // 1/4 speed of real system, but emulate-able //clock = new SystemClock(21477272); // True speed bus = new SystemBus(0xFFFF); RAM ram = new RAM(2048); ppu = new PPU(clock, bus); cpu = new CPU_2A03(new ClockDivider(clock, 3), bus); // 3x slower than PPU apu = new APU(new ClockDivider(clock, 6)); // 6x slower than PPU controllers[0] = new Controller(0x4016); controllers[1] = new Controller(0x4017); bus.AddComponent(ram, new BusAddressRange(0x0000, 0x1FFF)); bus.AddComponent(ppu, new BusAddressRange(0x2000, 0x3FFF)); bus.AddComponent(apu, new BusAddressRange(0x4000, 0x4013)); bus.AddComponent(cpu, new BusAddressRange(0x4014, 0x4014)); bus.AddComponent(apu, new BusAddressRange(0x4015, 0x4015)); bus.AddComponent((Controller)controllers[0], new BusAddressRange(0x4016, 0x4016)); bus.AddComponent((Controller)controllers[1], new BusAddressRange(0x4017, 0x4017)); bus.AddComponent(apu, new BusAddressRange(0x4017, 0x4017)); }
public void CanSleep() { SystemClock.UseTestClock(); var sw = Stopwatch.StartNew(); SystemClock.Sleep(250); sw.Stop(); Assert.InRange(sw.ElapsedMilliseconds, 225, 400); SystemClock.Test.UseFakeSleep(); var now = SystemClock.UtcNow; sw.Restart(); SystemClock.Sleep(1000); sw.Stop(); var afterSleepNow = SystemClock.UtcNow; Assert.InRange(sw.ElapsedMilliseconds, 0, 25); Assert.True(afterSleepNow > now); Assert.InRange(afterSleepNow.Subtract(now).TotalMilliseconds, 950, 1100); }
protected override async Task <JobResult> RunInternalAsync(JobContext context) { const int LIMIT = 100; _lastRun = SystemClock.UtcNow; _logger.LogTrace("Start save stack event counts."); // Get list of stacks where snooze has expired var results = await _stackRepository.GetExpiredSnoozedStatuses(SystemClock.UtcNow, o => o.PageLimit(LIMIT)).AnyContext(); while (results.Documents.Count > 0 && !context.CancellationToken.IsCancellationRequested) { foreach (var stack in results.Documents) { stack.MarkOpen(); } await _stackRepository.SaveAsync(results.Documents).AnyContext(); // Sleep so we are not hammering the backend. await SystemClock.SleepAsync(TimeSpan.FromSeconds(2.5)).AnyContext(); if (context.CancellationToken.IsCancellationRequested || !await results.NextPageAsync().AnyContext()) { break; } if (results.Documents.Count > 0) { await context.RenewLockAsync().AnyContext(); } } _logger.LogTrace("Finished save stack event counts."); return(JobResult.Success); }
private async Task CanRunConcurrentlyAsync(TimeSpan?minimumIntervalTime = null) { var countdown = new AsyncCountdownEvent(2); Func <Task <DateTime?> > callback = async() => { _logger.LogInformation("Starting work."); countdown.Signal(); await SystemClock.SleepAsync(500); _logger.LogInformation("Finished work."); return(null); }; using (var timer = new ScheduledTimer(callback, minimumIntervalTime: minimumIntervalTime, loggerFactory: Log)) { timer.ScheduleNext(); var t = Task.Run(async() => { for (int i = 0; i < 3; i++) { await SystemClock.SleepAsync(10); timer.ScheduleNext(); } }); _logger.LogInformation("Waiting for 300ms"); await countdown.WaitAsync(TimeSpan.FromMilliseconds(300)); _logger.LogInformation("Finished waiting for 300ms"); Assert.Equal(1, countdown.CurrentCount); _logger.LogInformation("Waiting for 1.5 seconds"); await countdown.WaitAsync(TimeSpan.FromSeconds(1.5)); _logger.LogInformation("Finished waiting for 1.5 seconds"); Assert.Equal(0, countdown.CurrentCount); } }
private void When_getting_file_creation_time_in_UTC_it_must_cache() { // Arrange const string path = @"c:\some\file.txt"; var clock = new SystemClock(() => DefaultTimeUtc); IFileSystem fileSystem = new FakeFileSystemBuilder(clock) .IncludingEmptyFile(path) .Build(); IFileInfo fileInfo = fileSystem.ConstructFileInfo(path); DateTime beforeTime = fileInfo.CreationTimeUtc; fileSystem.File.SetCreationTimeUtc(path, AlternateTimeUtc); // Act DateTime afterTime = fileInfo.CreationTimeUtc; // Assert beforeTime.Should().Be(DefaultTimeUtc); afterTime.Should().Be(DefaultTimeUtc); }
public void StatsIncr() { stats.Increment("cats"); stats.Increment("dogs", 3); collector.Periodic(null); stats.Increment("dogs", 60000); SystemClock.Advance(TimeSpan.FromMinutes(1)); collector.Periodic(null); var series = collector.Get("counter:dogs", null); series.ShouldNotBe(null); series.Count().ShouldBe(60); var seconds = SystemClock.Minus(TimeSpan.FromMinutes(2d)).MillisFromEpoch() / 1000; AssertClose(new List <long>(new[] { seconds, 0 }), series.ElementAt(57)); seconds = SystemClock.Minus(TimeSpan.FromMinutes(1d)).MillisFromEpoch() / 1000; AssertClose(new List <long>(new[] { seconds, 3 }), series.ElementAt(58)); AssertClose(new List <long>(new[] { SystemClock.Seconds(), 60000 }), series.ElementAt(59)); }
public TuckerRockyDropShipper(ITuckerRockyClient client, SystemClock clock, ITextFileReader fileReader) { _client = client; _clock = clock; _fileReader = fileReader; }
static SystemClock() { Instance = new SystemClock(); }
public ReadyDirectory(InstallationDirectory installationDirectory, SystemClock clock) { _readyLocation = installationDirectory.GetChildDirectory(LocationExtensions.Ready); _readyLocation.EnsureExists(); _clock = clock; }
public TuckerRockyVendor(ITextFileReader fileReader, IFileHelpersCache fileHelpersCache, SystemClock clock) { _fileReader = fileReader; _fileHelpersCache = fileHelpersCache; _clock = clock; }
/// <summary> /// Initializes a new instance of the <see cref="TransactionList"/> class. /// </summary> /// <param name="systemClock">The system clock.</param> public TransactionList(SystemClock systemClock) { Transactions = new List<Transaction>(); }
public SiteList(SystemClock systemClock) { Sites = new List<Site>(); Clock = systemClock; }
public VendorDirectory(Directory vendorLocation, IVendor vendor, SystemClock clock) { _vendorLocation = vendorLocation; _vendor = vendor; _clock = clock; }
public DropShipperDirectory(Directory dropShipperLocation, IDropShipper dropShipper, SystemClock clock) { _dropShipperLocation = dropShipperLocation; _dropShipper = dropShipper; _clock = clock; }