/// <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 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 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'");
}
