/// <summary> /// Reports a failed step, and throws an AssertInconclusiveException if needed. /// </summary> /// <param name="assert">The calling assert.</param> /// <param name="step">The <see cref="StepInfo"/> to report to.</param> /// <param name="actualState">The message to include as the actual result in the step, and in the exception.</param> /// <param name="continueOnError">If true, not exception is thrown. if false, <see cref="AssertFailedException"/> is thrown if the condition fails.</param> /// <exception cref="AssertInconclusiveException">Thrown if condition fails and <paramref name="continueOnError"/> is false.</exception> public static void ReportInconclusive(this Assert assert, StepInfo step, string actualState, bool continueOnError = false) { if (actualState != null) { step.Actual.Add(actualState); } if (((int)StepStatusEnum.Fail) > ((int)step.Outcome)) { step.Outcome = StepStatusEnum.Fail; } if (!continueOnError) { //StringBuilder message = new StringBuilder(); //StringBuilder numberedLines; //message.AppendLine(String.Format("STEP {0} [{1}]: Description = {2}", (String.IsNullOrEmpty(step.Name)) ? "" : step.Name, Timestamp.UnixTimestampToDateTime(step.StartTime).ToString(ConsoleReporter.TimeFormat), step.Description)); //numberedLines = NormalizeListToString(step.Expected); //message.AppendLine($"Expected = {numberedLines.ToString()}"); //numberedLines = NormalizeListToString(step.Actual); //message.AppendLine($"Actual = {numberedLines.ToString()}"); //message.AppendLine(String.Format("Outcome = {0}", Enum.GetName(typeof(StepStatusEnum), step.Outcome))); //numberedLines = NormalizeListToString(step.Messages); //message.AppendLine($"Messages: {numberedLines.ToString()}"); throw new AssertInconclusiveException(ConsoleReporter.CreateStepReport(step)); } }
internal async Task Run() { if (Task == null && Action == null) { ConsoleReporter.WriteLine($"{nameof(Task)} and {nameof(Action)} are both null in {nameof(Runnable)}"); return; } if (Task != null) { await Task.Compile().Invoke(); return; } var compiledAction = Action.Compile(); if (IsThisAsync(compiledAction)) { await System.Threading.Tasks.Task.Run(compiledAction); return; } compiledAction.Invoke(); }
static void Main(string[] args) { Model.Warehouse warehouse = new Model.Warehouse(); List <Item> warehouses = new List <Item>(); Item item = new Item() { Name = "Шампунь", Description = "Шампунь Head'n'Shoulders не шипит глаза", Price = 3000, WhenAdded = DateTime.Now }; ConsoleReporter consoleReporter = new ConsoleReporter(); Serializer serializer = new Serializer(); ConsoleKeyInfo key; while (true) { key = System.Console.ReadKey(true); if (key.Key == ConsoleKey.Enter) { warehouse.AddToWarehouse(warehouses, item); serializer.Serialize(warehouses); } consoleReporter.Report(); } }
public void Run(ConsoleReporter reporter) { context.SetParameter("dotNetReporter", reporter); context.Run(@" jasmine.JsApiReporter.prototype.reportSpecResults = function(spec) { this.totalSpecs += 1; if (spec.results().failedCount == 0) { dotNetReporter.Passed(spec.getFullName()); } else { this.totalFailures += 1; var errors = []; var results = spec.results().getItems(); for (var i = 0; i < results.length; i++) { if (results[i].trace.stack) { errors.push(results[i].trace.stack); } } dotNetReporter.Failed(spec.getFullName(), errors); } }; var jasmineEnv = jasmine.getEnv(); var reporter = new jasmine.JsApiReporter(); reporter.totalSpecs = 0; reporter.totalFailures = 0; jasmineEnv.addReporter(reporter); jasmineEnv.execute(); dotNetReporter.Finished(); "); }
static void _applet_Configure(object sender, EventArgs e) { bool quitApplet = false; ConsoleReporter.Report("Enter Config Mode...", ConsoleReporter.ReportStatus.Process, _logEnabled); _currentPageIndex = 2; _inConfigMode = true; AppStart_DBClient.Form1 configForm = new AppStart_DBClient.Form1(Constants.DB_FILEPATH); quitApplet = (configForm.ShowDialog() == System.Windows.Forms.DialogResult.Abort); ConsoleReporter.Report("Config completed!", ConsoleReporter.ReportStatus.Info, _logEnabled); if (quitApplet) { _mustExit = true; return; } InitDB(); InitSettings(); InitGraphics(_device); _currentPageIndex = 0; _inConfigMode = false; }
private int OnExecute(IConsole console) { var reporter = new ConsoleReporter(console); try { if (OutputPath == null) { OutputPath = Environment.CurrentDirectory; } if (FileHelper.IsNarc(InputPath)) { NarcArchive.ExtractTppk(InputPath, OutputPath); } else { TppkArchive.Extract(InputPath, OutputPath); } return(0); } catch (Exception e) { reporter.Error(e.Message); return(e.HResult); } }
static void InitSettings() { ConsoleReporter.Report("Loading settings...", ConsoleReporter.ReportStatus.Process, _logEnabled); // Get Settings Preference PREF_4th_openConfigEnabled = _db.GetPreferenceByKey("4th_OpenConfigEnabled"); if (PREF_4th_openConfigEnabled != null) { if (PREF_4th_openConfigEnabled.Type == typeof(bool)) { _configButtonEnabled = (bool)PREF_4th_openConfigEnabled.Value; } else { _configButtonEnabled = false; } } else { _configButtonEnabled = false; } ConsoleReporter.Report(String.Format("4th_OpenConfigEnabled: (BOOL) {0}", _configButtonEnabled), ConsoleReporter.ReportStatus.Error, _logEnabled); ConsoleReporter.Report("Loading settings completed", ConsoleReporter.ReportStatus.Info, _logEnabled); }
public static async Task AnalyseCodeInDirectory(string directoryName) { Console.WriteLine($"DEBUG: {nameof(AnalyserService)}.{nameof(AnalyseCodeInDirectory)} begin"); if (string.IsNullOrWhiteSpace(directoryName)) { throw new ArgumentNullException(nameof(directoryName)); } var project = DirectoryParser.Parse(directoryName); var syntaxTrees = await Task.WhenAll(project.Documents.Select(d => d.GetSyntaxTreeAsync())); var compilationRoots = syntaxTrees.Select(t => t.GetCompilationUnitRoot()); List <AnalyserItem> analyserItems = new List <AnalyserItem>(); foreach (var analyser in Analysers) { Console.WriteLine($"DEBUG: Starting {analyser.GetType().Name}"); foreach (var compilationRoot in compilationRoots) { analyser.Visit(compilationRoot); } Console.WriteLine($"DEBUG: Finished {analyser.GetType().Name}"); analyserItems.AddRange((analyser as IAnalyser).AnalyserItems); } await ConsoleReporter.Report(analyserItems); Console.WriteLine($"DEBUG: {nameof(AnalyserService)}.{nameof(AnalyseCodeInDirectory)} end"); }
static void Main(string[] args) { var db1Metrics = new MetricRegistry(); var reporter = ConsoleReporter.ForRegistry(db1Metrics).build(); var meter = db1Metrics.Meter("testMeter"); var randomHist = db1Metrics.Histogram("testHist"); //var machineMetrics = MachineMetrics.Create(MachineMetricsCategory.All); //db1Metrics.Register("MachineMetrics", machineMetrics); //reporter.Start(1, TimeUnit.Seconds); CsvReporter creporter = CsvReporter.forRegistry(db1Metrics).build("c:\\merchlog"); //creporter.Start(1, TimeUnit.Seconds); Graphite sender = new Graphite("ttolley-lap3", 2003); GraphiteReporter greporter = GraphiteReporter.ForRegistry(db1Metrics).Build(sender); greporter.Start(10, TimeUnit.Seconds); //var docsTimedCounterPerSec = db1Metrics.TimedCounter("db1", "docs new indexed/sec", "new Indexed Documents"); int i = 0; db1Metrics.Gauge <int>("testGauge", () => i); Random r = new Random(); var counter = db1Metrics.Counter("testCounter"); for (; i < 10000; i++) { meter.Mark(); counter.Increment(i); randomHist.Update(r.Next(101)); Thread.Sleep(100); } Console.WriteLine("Done counting"); for (i = 0; i < 10; i++) { Thread.Sleep(60000); } //Console.WriteLine(docsTimedCounterPerSec.CurrentValue); /*var RequestsPerSecondHistogram = db1Metrics.Histogram("db1.Request Per Second Histogram"); * for (int i = 0; i < 100; i++) * { * RequestsPerSecondCounter.Mark(); * RequestsPerSecondHistogram.Update((long)RequestsPerSecondCounter.CurrentValue); * Thread.Sleep(10); * } * StringBuilder sb = new StringBuilder(); * double[] res; * var perc = RequestsPerSecondHistogram.Percentiles(0.5, 0.75, 0.95, 0.98, 0.99, 0.999); * res = perc; * RequestsPerSecondHistogram.LogJson(sb,perc); * Console.WriteLine(sb); * Console.WriteLine(RequestsPerSecondHistogram.Percentiles(0.5, 0.75, 0.95, 0.98, 0.99, 0.999)); * // RequestsPerSecondHistogram.Update((long)documentDatabase.WorkContext.MetricsCounters.RequestsPerSecondCounter.CurrentValue); //?? */ }
public EtwPerformanceMetricLogger(XunitPerformanceProject project, Program program) { _etlPath = Path.Combine(project.OutputDir, project.OutputBaseFileName + ".etl"); _program = program; _project = project; var diagnosticMessageSink = new ConsoleReporter(); foreach (var assembly in project.Assemblies) { program.PrintIfVerbose($"Discovering tests for {assembly.AssemblyFilename}."); // Note: We do not use shadowCopy because that creates a new AppDomain which can cause // assembly load failures with delay-signed or "fake signed" assemblies. using (var controller = new XunitFrontController( assemblyFileName: assembly.AssemblyFilename, shadowCopy: false, appDomainSupport: AppDomainSupport.Denied, diagnosticMessageSink: new ConsoleDiagnosticsMessageVisitor()) ) using (var discoveryVisitor = new PerformanceTestDiscoveryVisitor(assembly, project.Filters, diagnosticMessageSink)) { controller.Find(includeSourceInformation: false, messageSink: discoveryVisitor, discoveryOptions: TestFrameworkOptions.ForDiscovery()); discoveryVisitor.Finished.WaitOne(); _tests.AddRange(discoveryVisitor.Tests); } } program.PrintIfVerbose($"Discovered a total of {_tests.Count} tests."); }
public override Task Report(CancellationToken cancellationToken = default) { if (_logger == null || cancellationToken.IsCancellationRequested) { return(Task.CompletedTask); } try { using var stream = new MemoryStream(); var encoding = Encoding.UTF8; using (var writer = new StreamWriter(stream, encoding)) { if (!ConsoleReporter.TryWrite(_registry, writer, cancellationToken) && _options.Value.StopOnError) { Stop(); return(Task.CompletedTask); } } _logger.Log(_options.Value.LogLevel, encoding.GetString(stream.ToArray())); } catch (Exception e) { _logger?.LogError(e, "Error reporting metrics to logger"); if (_options.Value.StopOnError) { Stop(); } } return(Task.CompletedTask); }
public static void Main(string[] args) { MetricsStorage storage = new RedisMetricsStorage(); ConsoleReporter consoleReporter = new ConsoleReporter(storage); consoleReporter.startRepeatedReport(60, 60); MetricsCollector collector = new MetricsCollector(storage); collector.recordRequest(new RequestInfo("register", 123, 10234)); collector.recordRequest(new RequestInfo("register", 223, 11234)); collector.recordRequest(new RequestInfo("register", 323, 12334)); collector.recordRequest(new RequestInfo("login", 23, 12434)); collector.recordRequest(new RequestInfo("login", 1223, 14234)); try { Thread.Sleep(100000); } catch (Exception e) { throw new Exception(); } }
public void Can_run_in_background() { const int ticks = 3; var block = new ManualResetEvent(false); RegisterMetrics(); ThreadPool.QueueUserWorkItem( s => { var reporter = new ConsoleReporter(); reporter.Start(3, TimeUnit.Seconds); while (true) { Thread.Sleep(1000); var runs = reporter.Runs; if (runs == ticks) { block.Set(); } } } ); block.WaitOne(TimeSpan.FromSeconds(5)); }
public async Task ApplyAnUpdate( IReadOnlyCollection <PackageUpdateSet> updates, NuGetSources sources) { if (!updates.Any()) { return; } var filtered = await _selection .Filter(updates, p => Task.FromResult(true)); if (!filtered.Any()) { _logger.Detailed("All updates were filtered out"); return; } var candidate = filtered.First(); var reporter = new ConsoleReporter(); _logger.Minimal("Updating " + reporter.Describe(candidate)); await _updateRunner.Update(candidate, sources); }
public void SetAndGetLogLevel(LogLevel logLevel) { var consoleReporter = new ConsoleReporter(); consoleReporter.SetLogLevel(logLevel); Assert.Equal(logLevel, consoleReporter.GetLogLevel()); }
public static int Main(string[] args) { try { var app = new CommandLineApplication { Name = "dotnet-developercertificates" }; app.Command("https", c => { var exportPath = c.Option("-ep|--export-path", "Full path to the exported certificate", CommandOptionType.SingleValue); var password = c.Option("-p|--password", "Password to use when exporting the certificate with the private key into a pfx file", CommandOptionType.SingleValue); CommandOption trust = null; if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { trust = c.Option("-t|--trust", "Trust the certificate on the current platform", CommandOptionType.NoValue); } var verbose = c.Option("-v|--verbose", "Display more debug information.", CommandOptionType.NoValue); var quiet = c.Option("-q|--quiet", "Display warnings and errors only.", CommandOptionType.NoValue); c.HelpOption("-h|--help"); c.OnExecute(() => { var reporter = new ConsoleReporter(PhysicalConsole.Singleton, verbose.HasValue(), quiet.HasValue()); return(EnsureHttpsCertificate(exportPath, password, trust, reporter)); }); }); app.HelpOption("-h|--help"); app.OnExecute(() => { app.ShowHelp(); return(Success); }); return(app.Execute(args)); } catch { return(CriticalError); } }
public static void Configure(CommandLineApplication app, CommandLineOptions options, IConsole console) { // description app.Description = "Creates a new user"; app.ExtendedHelpText = $"{Environment.NewLine}Use 'users add -i' to enter interactive mode{Environment.NewLine}"; // arguments var argumentUserId = app.Argument("id", "The user subject identifier", false); var argumentClientTier = app.Argument("tier", string.Concat("The user client tier (", string.Join(" | ", Enum.GetNames(typeof(ClientTierDto))), ")"), false); // options var optionDefaultAssetAccountId = app.Option("-a|--default_account <default_account>", "The default asset account id for the user", CommandOptionType.SingleValue); var optionInteractive = app.Option("-i|--interactive", "Enters interactive mode", CommandOptionType.NoValue); // action (for this command) app.OnExecute( () => { ClientTierDto tier = default; if ((string.IsNullOrEmpty(argumentUserId.Value) || !Enum.TryParse(argumentClientTier.Value, true, out tier)) && !optionInteractive.HasValue()) { app.ShowVersionAndHelp(); return; } var reporter = new ConsoleReporter(console, options.Verbose.HasValue(), false); var helper = new UserHelper(); var user = new User { UserId = argumentUserId.Value, ClientTier = tier, DefaultAssetAccountId = optionDefaultAssetAccountId.Value(), }; reporter.Verbose("Prototype user (from command line arguments):"); reporter.Verbose(JsonConvert.SerializeObject(user)); if (!helper.IsValid(user) || optionInteractive.HasValue()) { try { user = helper.GetValid(user); } catch (NotSupportedException ex) { throw new CommandParsingException(app, $"Operation Aborted. {ex.Message}", ex); } reporter.Verbose("Validated user (from interactive console):"); reporter.Verbose(JsonConvert.SerializeObject(user)); } options.Command = new AddUserCommand { user = user }; }); }
public void Can_run_with_known_counters_and_human_readable_format() { RegisterMetrics(); var reporter = new ConsoleReporter(); reporter.Run(); }
public void Can_run_with_known_counters_and_json_format() { RegisterMetrics(); var reporter = new ConsoleReporter(new JsonReportFormatter()); reporter.Run(); }
private void WriteStoryAndScenario(Scenario scenario) { ConsoleReporter.WriteStory(scenario.StoryText); ConsoleReporter.WriteScenario(scenario.ScenarioText); ConsoleReporter.WriteLine(Environment.NewLine); }
public void DoesNotRedirectTheStandardOutputStream() { TextWriter before = Console.Out; _ = new ConsoleReporter(); TextWriter after = Console.Out; Assert.Same(before, after); }
public void QuickTestReporter() { var consoleReporter = new ConsoleReporter(); consoleReporter.SetLogLevel(LogLevel.Verbose); consoleReporter.Log(LogLevel.Info, "Test Message"); consoleReporter.Log(LogLevel.Info, "Test Message", "TAG"); consoleReporter.Log(LogLevel.Error, "Test Message", new Exception("My Exception", new Exception("My inner exception")), "TAG"); }
private void WriteCustomTestInformation(Scenario scenario) { foreach (var testInformationAttribute in scenario.CustomTestInformation ?? Array.Empty <TestInformationAttribute>()) { ConsoleReporter.WriteLine(testInformationAttribute.Print()); } ConsoleReporter.WriteLine(Environment.NewLine); }
public static int Main() { var runner = new TestRunner(); var reporter = new ConsoleReporter(); runner.Run(reporter); return reporter.TotalFailures == 0 ? 0 : 1; }
public Runner(CommandLineOptions options, IConsole console) { _options = options; _console = console; _reporter = new ConsoleReporter(console) { IsQuiet = options.Quiet, IsVerbose = options.Verbose, }; }
static void InitGraphics(LcdDevice device) { ConsoleReporter.Report("Initializing Graphics...", ConsoleReporter.ReportStatus.Process, _logEnabled); pageList = new List <LcdGdiPage>(); Draw(device); device.CurrentPage = pageList[0]; device.SetAsForegroundApplet = true; ConsoleReporter.Report("Initializing Graphics done", ConsoleReporter.ReportStatus.Info, _logEnabled); }
public async Task BaselineTest(SharedFxConfig config) { var previousVersion = TestData.GetPreviousAspNetCoreReleaseVersion(); var url = new Uri($"https://dotnetcli.blob.core.windows.net/dotnet/aspnetcore/Runtime/" + previousVersion + "/aspnetcore-runtime-internal-" + previousVersion + "-win-x64.zip"); var zipName = "assemblies.zip"; var nugetAssemblyVersions = new Dictionary <string, Version>(); var dir = TestData.GetTestDataValue($"RuntimeAssetsOutputPath:{config.Name}"); using (var testClient = new WebClient()) { var reporter = new ConsoleReporter(PhysicalConsole.Singleton); await RetryHelpers.RetryAsync(async() => await testClient.DownloadFileTaskAsync(url, zipName), reporter); } var zipPath = Path.Combine(AppContext.BaseDirectory, zipName); var tempDirectoryPath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()); try { Directory.CreateDirectory(tempDirectoryPath); ZipFile.ExtractToDirectory(zipPath, tempDirectoryPath); var nugetAssembliesPath = Path.Combine(tempDirectoryPath, "shared", config.Name, previousVersion); var files = Directory.GetFiles(nugetAssembliesPath, "*.dll"); foreach (var file in files) { try { var assemblyVersion = AssemblyName.GetAssemblyName(file).Version; var dllName = Path.GetFileName(file); nugetAssemblyVersions.Add(dllName, assemblyVersion); } catch (BadImageFormatException) { } } files = Directory.GetFiles(dir, "*.dll"); Assert.All(files, file => { try { var localAssemblyVersion = AssemblyName.GetAssemblyName(file).Version; var dllName = Path.GetFileName(file); Assert.Contains(dllName, nugetAssemblyVersions.Keys); Assert.InRange(localAssemblyVersion.CompareTo(nugetAssemblyVersions[dllName]), 0, int.MaxValue); } catch (BadImageFormatException) { } }); } finally { Directory.Delete(tempDirectoryPath, true); } }
static void Main(string[] args) { var cmdArgsRetriever = new CommandLineArgumentsRetriever(); var sourcePath = cmdArgsRetriever.GetSourcePath(args); //sourcePath = "https://jsonblob.com/api/80a3e281-c4fb-11e9-9e37-89e98d519613"; var factory = new StockQuoteRetrieverFactory(); var retriever = factory.GetTradeRetriever(sourcePath); var trades = retriever.GetStockQuotes(sourcePath).ToList(); var analyzer = new StockQuoteAnalyzer(); analyzer.PivotDownsideFoundEvent += PivotDownsideFoundEventHandler; analyzer.PivotUpsideFoundEvent += PivotUpsideFoundEventHandler; var reversals = analyzer.LocateReversal(trades).AsParallel(); var reporter = new ConsoleReporter(); reporter.Report(reversals); //var timeAnalyzer = new TimeAnalyzer(); //var elapsed = timeAnalyzer.Measure(() => PrimeNumberAnalyzer.FindLargePrimesInParallel(900000, 910000)); //Console.WriteLine(elapsed.TotalMilliseconds); //var date = new List<DateTime>(); //var open = new List<decimal>(); //var high = new List<decimal>(); //var low = new List<decimal>(); //var close = new List<decimal>(); //var provider = CultureInfo.InvariantCulture; //var lines = File.ReadAllLines(args[0]); //for (int i = 1; i < lines.Length; i++) //{ // var data = lines[i].Split(','); // date.Add(DateTime.Parse(data[0], CultureInfo.InvariantCulture)); // open.Add(decimal.Parse(data[1])); // high.Add(decimal.Parse(data[2])); // low.Add(decimal.Parse(data[3])); // close.Add(decimal.Parse(data[4])); //} //for (int i = 0; i < date.Count - 4; i++) //{ // if (open[i] > high[i + 1] && close[i] < low[i + 1]) // { // Console.ForegroundColor = ConsoleColor.Red; // Console.WriteLine("Pivot downside {0}", date[i].ToShortDateString()); // } // if (open[i] < low[i + 1] && close[i] > high[i + 1]) // { // Console.ForegroundColor = ConsoleColor.Green; // Console.WriteLine("Pivot upside {0}", date[i].ToShortDateString()); // } //} }
private static string GetExpressionValue(Expression argument) { try { var argumentValue = argument is ConstantExpression constantExpression ? constantExpression.Value?.ToString() : Expression.Lambda(Expression.Convert(argument, argument.Type)).Compile().DynamicInvoke(); if (argumentValue == null) { return("null"); } var stepTextStringConverter = BDTestSettings.CustomStringConverters .FirstOrDefault(type => type.GetType().GetInterfaces().FirstOrDefault()?.Name.StartsWith(nameof(IStepTextStringConverter <object>)) == true && type.GetType().GetInterfaces().FirstOrDefault()?.GetGenericArguments().FirstOrDefault() == argumentValue.GetType()); if (stepTextStringConverter != null) { var method = stepTextStringConverter.GetType().GetMethod(nameof(IStepTextStringConverter <object> .ConvertToString)); if (method != null) { return(method.Invoke(stepTextStringConverter, new[] { argumentValue }) as string); } } if (TypeHelper.IsFuncOrAction(argumentValue.GetType())) { var func = (Delegate)argumentValue; return(func.DynamicInvoke()?.ToString()); } if (TypeHelper.IsIEnumerable(argumentValue) || argumentValue.GetType().IsArray) { return(string.Join(", ", (IEnumerable <object>)argumentValue)); } if (TypeHelper.IsIDictionary(argumentValue)) { return(string.Join(",", ((IDictionary <object, object>)argumentValue).Select(kv => $"{kv.Key}={kv.Value}") )); } return(argumentValue.ToString()); } catch (Exception e) { ConsoleReporter.WriteLine($"BDTest Exception:{Environment.NewLine}Class: {nameof(StepTextHelper)}{Environment.NewLine}Method: {nameof(GetExpressionValue)}{Environment.NewLine}Exception: {e.Message}{Environment.NewLine}{e.StackTrace}"); return("null"); } }
static void Main(string[] args) { var r1 = new ConsoleReporter(); sample(r1); var r2 = new LogReporter(); sample(r2); var r3 = new MailReporter(); sample(r3); }
private async Task ResetData(Scenario scenario) { SetRetryData(scenario); ResetStepData(scenario); scenario.Status = Status.Inconclusive; await RunRetryTestHooks(scenario).ConfigureAwait(false); ConsoleReporter.WriteLine($"{Environment.NewLine}Retrying test...{Environment.NewLine}"); }
private async Task ApplyUpdates(IReadOnlyCollection <PackageUpdateSet> updates, IFolder workingFolder, NuGetSources sources) { await _solutionsRestore.CheckRestore(updates, workingFolder, sources); foreach (var update in updates) { var reporter = new ConsoleReporter(); _logger.Minimal("Updating " + reporter.Describe(update)); await _updateRunner.Update(update, sources); } }
public VKDownloader(DownloaderArgs args) { _args = args; _reporter = new ConsoleReporter<ConsoleState>(new ConsoleState(), state => { var sb = ImmutableList<string>.Empty; sb = sb.Add(state.CurrentOperation); sb = sb.Add(""); sb = sb.Add(state.CurrentOperationStatus); sb = sb.Add(""); sb = state.Downloads.Aggregate(sb, (current, item) => current.Add($"[{item.PercentComplete}]: {item.Title}")); sb = sb.Add(""); if (state.TotalBytes > 0) { var totalMb = state.TotalBytes / (double)(1024 * 1024); var avgSpeed = totalMb / _stopwatch.Elapsed.TotalSeconds; sb = sb.Add($"So far, downloaded {state.ItemsDownloaded} songs"); sb = sb.Add($"{totalMb.ToString("0.00")} Mb - {avgSpeed.ToString("0.00")} Mb/s"); if (state.TotalSongsToDownload > 0) { var songAvgSize = totalMb / (state.ItemsDownloaded == 0 ? 1 : state.ItemsDownloaded); var estSizeToDownload = songAvgSize*state.TotalSongsToDownload; var eta = TimeSpan.FromSeconds((estSizeToDownload - totalMb) / avgSpeed); sb = sb.Add($"Elapsed: {_stopwatch.Elapsed.ToString(@"hh\:mm\:ss")} ETA: {eta.ToString(@"hh\:mm\:ss")}"); } } return sb; }); if (string.IsNullOrWhiteSpace(args.Folder)) throw new Exception("Folder should be specified! '-folder'"); }