public void Report_EmptyProgress() { var progress = AggregateProgress.CreateEmpty <int>(); progress.Report(1); progress.Report(2); }
public void SinglePercentNode() { var progress = new Mock <IProgress <double> > (); var aggregate = new AggregateProgress(progress.Object, holdForDiscovery: false); IProgress <double> node = aggregate.CreateProgressNode(); node.Report(5); progress.Verify(p => p.Report(5)); }
public void Report_SingleProgress() { var progress = new Mock <IProgress <int> >(); var aggregate = AggregateProgress.Create(progress.Object); aggregate.Report(1); aggregate.Report(2); progress.Verify(mock => mock.Report(1), Times.Once); progress.Verify(mock => mock.Report(2), Times.Once); progress.VerifyNoOtherCalls(); }
public static async Task ImportAsync(IReadOnlyList <IStorageItem> items, IProgress <double> progress = null) { items = GetImportableItems(items); AggregateProgress total = (progress != null) ? new AggregateProgress(progress) : null; ISyncService sync = await App.Services.GetServiceAsync <ISyncService> ().ConfigureAwait(false); DownloadManager downloads = await App.Services.GetServiceAsync <DownloadManager> ().ConfigureAwait(false); List <Task> importTasks = new List <Task> (); foreach (IStorageItem item in items) { var node = total?.CreateProgressNode(); if (item is IStorageFolder folder) { var children = await folder.GetItemsAsync(); importTasks.Add(ImportAsync(children, node)); } else if (item is IStorageFile file) { Task <FileSample> import = null; ManagedDownload download = null; Func <CancellationToken, IProgress <double>, Task <FileSample> > importGetter = async(cancel, progress) => { import = ImportAsync(file, sync, progress, cancel); FileSample sample = null; try { sample = await import; if (download != null) { download.State = DownloadState.Completed; } } catch { if (download != null) { download.State = DownloadState.LocalError; } } return(sample); }; download = downloads.QueueImport(file.Name, importGetter); importTasks.Add(import); } } total?.FinishDiscovery(); await Task.WhenAll(importTasks); }
public void PreallocateNodes() { var progress = new Mock <IProgress <double> > (); var aggregate = new AggregateProgress(progress.Object, holdForDiscovery: true); aggregate.FinishDiscovery(10); IProgress <double> node = aggregate.PopNode(); Assert.That(node, Is.Not.Null); node.Report(1); progress.Verify(p => p.Report(It.IsInRange(0.09, 0.11, Moq.Range.Inclusive))); }
public void MultiplePercentNodes() { var progress = new Mock <IProgress <double> > (); var aggregate = new AggregateProgress(progress.Object, holdForDiscovery: false); IProgress <double> node = aggregate.CreateProgressNode(); IProgress <double> node2 = aggregate.CreateProgressNode(); node.Report(5); progress.Verify(p => p.Report(It.IsInRange(2.4, 2.51, Moq.Range.Inclusive))); node2.Report(5); progress.Verify(p => p.Report(It.IsInRange(4.9, 5.1, Moq.Range.Inclusive))); }
/// <summary> /// Load the query synchronously. <see cref="Cancellation"/> is used for cancellation /// token, <see cref="Progress"/> is used for reporting progress. /// </summary> /// <remarks> /// Found entities are added to a waiting queue. Use <see cref="Update"/> to get all /// entities loaded so far. /// </remarks> /// <seealso cref="RunAsync"/> public void Run() { var progress = AggregateProgress.Create( Progress, new FolderQueryProgress(_fileWatcher)); var options = new ExecutionOptions { CancellationToken = Cancellation.Token, Progress = progress }; foreach (var entity in Query.Execute(options)) { var thumbnail = _thumbnailFactory.Create(entity, Cancellation.Token); EnqueueRequest(new AddRequest(new EntityView(entity, thumbnail))); } }
public async Task <IReadOnlyList <FileSample> > EnsureElementPresentAsync(EnvironmentElement element, IProgress <double> progress = null, CancellationToken cancellationToken = default) { if (element is null) { throw new ArgumentNullException(nameof(element)); } await this.loadedServices.ConfigureAwait(false); List <Task> tasks = new List <Task> (); List <FileSample> samples = new List <FileSample> (); AggregateProgress totalProgress = (progress != null) ? new AggregateProgress(progress) : null; if (element.Audio != null) { foreach (string sampleId in element.Audio.Playlist.Descriptors) { FileSample sample = (await this.sync.GetElementByIdAsync(sampleId).ConfigureAwait(false) as FileSample); if (sample == null) { continue; } IProgress <double> nodeProgress = totalProgress?.CreateProgressNode(); samples.Add(sample); tasks.Add(this.downloadManager.EnsurePresentAsync(sample, nodeProgress, cancellationToken)); } } totalProgress?.FinishDiscovery(); int offset = 0; for (int i = 0; i < tasks.Count; i++) { try { await tasks[i].ConfigureAwait(false); } catch { samples.RemoveAt(i - offset++); } } return(samples); }
public void Report_MultipleProgressObjects() { var progress = new[] { new Mock <IProgress <int> >(), new Mock <IProgress <int> >(), new Mock <IProgress <int> >(), }; var aggregate = AggregateProgress.Create(progress.Select(item => item.Object).ToArray()); aggregate.Report(1); aggregate.Report(2); foreach (var item in progress) { item.Verify(mock => mock.Report(1), Times.Once); item.Verify(mock => mock.Report(2), Times.Once); item.VerifyNoOtherCalls(); } }
public async Task <PlaybackEnvironment> PrepareEncounterStateAsync(EncounterState encounterState, IProgress <double> progress = null, CancellationToken cancellationToken = default) { if (encounterState is null) { throw new ArgumentNullException(nameof(encounterState)); } await this.loadedServices.ConfigureAwait(false); AggregateProgress totalProgress = (progress != null) ? new AggregateProgress(progress) : null; var elements = new List <(EncounterStateElement, EnvironmentElement)> (); var presentTasks = new List <Task <IReadOnlyList <FileSample> > > (); foreach (EncounterStateElement stateElement in encounterState.EnvironmentElements) { EnvironmentElement element = await this.sync.GetElementByIdAsync <EnvironmentElement> (stateElement.ElementId).ConfigureAwait(false); elements.Add((stateElement, element)); presentTasks.Add(EnsureElementPresentAsync(element, totalProgress?.CreateProgressNode(), cancellationToken)); } // Lower level errors should be handled by EnsurePresent. // If EnsurePresent fails we should bubble up because we can't be sure we can prepare the encounter. await Task.WhenAll(presentTasks).ConfigureAwait(false); var playbackElements = new List <PlaybackEnvironmentElement> (elements.Count); for (int i = 0; i < elements.Count; i++) { (var state, var element) = elements[i]; playbackElements.Add(new PlaybackEnvironmentElement(state, element)); //, presentTasks[i].Result)); } return(new PlaybackEnvironment(playbackElements)); }
public async Task <string[]> DownloadScreenshots(string screenshotDirectory, IEnumerable <string> downloadUrls, [CanBeNull] IProgress <int> progress = null) { var totalProgress = new AggregateProgress <int>(progressValues => { progress?.Report((int)progressValues.Average()); }); var downloadTasks = new List <Task <ImageEntry> >(); foreach (var downloadUrl in downloadUrls) { var itemProgress = new Progress <int>(); totalProgress.Add(itemProgress); downloadTasks.Add(Task.Run(() => scraper.DownloadScreenshot(downloadUrl, itemProgress))); } EnsureDirectory(screenshotDirectory); var saveImageTasks = downloadTasks .Select(task => task.ContinueWith(t => WriteImage(screenshotDirectory, t))) .ToList(); try { return(await Task.WhenAll(saveImageTasks)); } catch (AggregateException) { return(saveImageTasks .Where(t => t.Status == TaskStatus.RanToCompletion) .Select(t => t.Result) .ToArray()); } }