/// <inheritdoc />
protected override int RunImpl(string[] args)
{
if (!ParseArguments(args))
{
ShowHelp();
return(1);
}
if (Arguments.Help)
{
ShowHelp();
return(0);
}
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
var runtimeSetup = new RuntimeSetup();
GenericCollectionUtils.ForEach(Arguments.PluginDirectories, x => runtimeSetup.AddPluginDirectory(x));
ILogger logger = new FilteredLogger(new RichConsoleLogger(Console), Verbosity.Normal);
using (RuntimeBootstrap.Initialize(runtimeSetup, logger))
{
IControlPanelPresenter presenter = RuntimeAccessor.Instance.ServiceLocator.Resolve <IControlPanelPresenter>();
presenter.Show(null);
}
return(0);
}
public void Construction()
{
Assert.That(() => new FilteredLogger(null, LogFilterLevel.None), Throws.ArgumentNullException);
var candidate = new FilteredLogger(new NullLogger(), LogFilterLevel.None);
Assert.That(candidate, Is.Not.Null);
}
protected override int RunImpl(string[] args)
{
if (!ParseArguments(args))
{
ShowHelp();
return(1);
}
if (Arguments.Help)
{
ShowHelp();
return(0);
}
RuntimeSetup runtimeSetup = new RuntimeSetup();
runtimeSetup.RuntimePath = runtimePath;
foreach (string pluginDirectory in Arguments.PluginDirectories)
{
runtimeSetup.AddPluginDirectory(pluginDirectory);
}
RichConsoleLogger runtimeLogger = new RichConsoleLogger(Console);
FilteredLogger filteredLogger = new FilteredLogger(runtimeLogger, Arguments.Verbosity);
RuntimeBootstrap.Initialize(runtimeSetup, filteredLogger);
runtimeLogger.Log(LogSeverity.Important, "This program is a stub...");
return(0);
}
public void Debug(LogFilterLevel level, string message, int expectedMessageCount)
{
var testLogger = new testLogger();
var logger = new FilteredLogger(testLogger, level);
logger.Debug(message);
Assert.That(testLogger.Messages.Count(), Is.EqualTo(expectedMessageCount));
if (expectedMessageCount > 0)
{
Assert.That(testLogger.Messages.First(), Is.EqualTo(message));
}
}
public void AssertThat_Errors_CauseTracesToBeLoggedAsWell()
{
IList <LogEntry> logList = new List <LogEntry>();
var filter = new TriggerableLevelFilter(
CommonLogSeverity.Information,
CommonLogSeverity.Error,
CommonLogSeverity.Trace
);
var outputStream = new ListOutputStream <LogEntry>(logList);
using var logger = new FilteredLogger(
new OutputLogger(outputStream),
filter.Apply
);
logger.LogTrace(new EventId(1, ""), new { });
// assert nothing has been written
Assert.Equal(0, logList.Count);
logger.LogInformation(new EventId(2, ""), new { });
// assert information has been written
Assert.Equal(1, logList.Count);
Assert.Equal(2, logList[0].EventId.Id);
logger.LogError(new EventId(3, ""), new { });
// assert information, trace and error have been written
Assert.Equal(3, logList.Count);
Assert.Equal(2, logList[0].EventId.Id);
Assert.Equal(1, logList[1].EventId.Id);
Assert.Equal(3, logList[2].EventId.Id);
logger.LogTrace(new EventId(4, ""), new { });
// assert information, trace, error an trace have been written
Assert.Equal(4, logList.Count);
Assert.Equal(2, logList[0].EventId.Id);
Assert.Equal(1, logList[1].EventId.Id);
Assert.Equal(3, logList[2].EventId.Id);
Assert.Equal(4, logList[3].EventId.Id);
}
/// <inheritdoc />
protected override int RunImpl(string[] args)
{
if (!ParseArguments(args))
{
ShowHelp();
return(1);
}
if (Arguments.Help)
{
ShowHelp();
return(0);
}
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
UnhandledErrorPolicy();
var runtimeSetup = CreateRuntimeSetup();
var logger = new FilteredLogger(new RichConsoleLogger(Console), Verbosity.Normal);
using (RuntimeBootstrap.Initialize(runtimeSetup, logger))
{
var scanner = new ComponentScanner(RuntimeAccessor.Registry);
scanner.Scan();
var copyController = RuntimeAccessor.ServiceLocator.Resolve <ICopyController>();
var progressController = RuntimeAccessor.ServiceLocator.Resolve <IProgressController>();
var copyForm = new CopyForm(copyController, progressController);
ErrorDialogUnhandledExceptionHandler.RunApplicationWithHandler(copyForm);
}
return(ResultCode.Success);
}
public static void Main(string[] args)
{
PrintAbout();
bool pauseOnExit = true;
var consoleLogger = new FilteredLogger(new ConsoleLogger());
var counter = new LogCounter();
var loggers = new LoggerCollection {
consoleLogger, counter
};
FileOutputLogger fileLogger = null;
var parser = new CommandLineParser();
foreach (var @switch in CommandLineSwitches.AllSwitches)
{
parser.AddSwitch(@switch);
}
try
{
var result = parser.Parse(args);
if (result.Flags.Contains(CommandLineSwitches.EnableTroublenoobing))
{
throw new DevirtualisationException("Magikarp uses Splash! It was not very effective...");
}
pauseOnExit = !result.Flags.Contains(CommandLineSwitches.NoPause);
if (result.Flags.Contains(CommandLineSwitches.Help))
{
PrintHelp();
}
else
{
consoleLogger.IncludeDebug = result.Flags.Contains(CommandLineSwitches.VerboseOutput) ||
result.Flags.Contains(CommandLineSwitches.VeryVerboseOutput);
consoleLogger.IncludeDebug2 = result.Flags.Contains(CommandLineSwitches.VeryVerboseOutput);
var options = GetDevirtualisationOptions(result);
options.OutputOptions.EnsureDirectoriesExist();
if (result.Flags.Contains(CommandLineSwitches.OutputLogFile))
{
fileLogger =
new FileOutputLogger(Path.Combine(options.OutputOptions.RootDirectory, "report.log"));
loggers.Add(fileLogger);
}
if (result.Flags.Contains(CommandLineSwitches.SalvageData))
{
loggers.Warning(Tag,
"Salvage mode is enabled. Output files might not be an accurate representation of the original binary.");
}
var devirtualiser = new Devirtualiser(loggers);
devirtualiser.Devirtualise(options);
}
}
catch (CommandLineParseException ex)
{
consoleLogger.Error(Tag, ex.Message);
consoleLogger.Log(Tag, "Use -h for help.");
}
catch (Exception ex) when(!Debugger.IsAttached)
{
consoleLogger.Error(Tag, "Something went wrong! Try the latest version or report a bug at the repository.");
if (consoleLogger.IncludeDebug)
{
loggers.Error(Tag, ex.ToString());
}
else
{
PrintExceptions(new LoggerCollection {
consoleLogger, counter
}, new[] { ex });
fileLogger?.Error(Tag, ex.ToString());
consoleLogger.Error(Tag, "Use --verbose or inspect the full report.log using --log-file for more details.");
}
}
finally
{
loggers.Log(Tag, $"Process finished with {counter.Warnings} warnings and {counter.Errors} errors.");
fileLogger?.Dispose();
}
if (pauseOnExit)
{
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
}
private FacadeTestRunState Run(IFacadeTestListener testListener, string assemblyPath, Filter <ITestDescriptor> filter, FacadeOptions facadeOptions)
{
if (testListener == null)
{
throw new ArgumentNullException(@"testListener");
}
if (assemblyPath == null)
{
throw new ArgumentNullException("assemblyPath");
}
if (facadeOptions == null)
{
throw new ArgumentNullException("facadeOptions");
}
ILogger logger = new FilteredLogger(new TDNetLogger(testListener), LogSeverity.Info);
try
{
RuntimeAccessor.Instance.AddLogListener(logger);
var filterRules = new List <FilterRule <ITestDescriptor> >();
switch (facadeOptions.FilterCategoryMode)
{
case FacadeFilterCategoryMode.Disabled:
filterRules.Add(new FilterRule <ITestDescriptor>(FilterRuleType.Inclusion, filter));
break;
case FacadeFilterCategoryMode.Include:
filterRules.Add(new FilterRule <ITestDescriptor>(FilterRuleType.Inclusion,
new AndFilter <ITestDescriptor>(new[] { filter, ToCategoryFilter(facadeOptions.FilterCategoryNames) })));
break;
case FacadeFilterCategoryMode.Exclude:
filterRules.Add(new FilterRule <ITestDescriptor>(FilterRuleType.Exclusion, ToCategoryFilter(facadeOptions.FilterCategoryNames)));
filterRules.Add(new FilterRule <ITestDescriptor>(FilterRuleType.Inclusion, filter));
break;
}
var filterSet = new FilterSet <ITestDescriptor>(filterRules);
launcher.Logger = logger;
launcher.ProgressMonitorProvider = new LogProgressMonitorProvider(logger);
launcher.TestExecutionOptions.FilterSet = filterSet;
launcher.TestProject.TestRunnerFactoryName = StandardTestRunnerFactoryNames.IsolatedAppDomain;
launcher.TestProject.AddTestRunnerExtension(new TDNetExtension(testListener)); // This monitor will inform the user in real-time what's going on
launcher.TestProject.TestPackage.AddFile(new FileInfo(assemblyPath));
string assemblyDirectory = Path.GetDirectoryName(assemblyPath);
launcher.TestProject.TestPackage.ApplicationBaseDirectory = new DirectoryInfo(assemblyDirectory);
launcher.TestProject.TestPackage.WorkingDirectory = new DirectoryInfo(assemblyDirectory);
TestLauncherResult result = RunLauncher(launcher);
string reportDirectory = GetReportDirectory(logger);
if (reportDirectory != null)
{
var reportFormatterOptions = new ReportFormatterOptions();
var preferenceManager = (TDNetPreferenceManager)RuntimeAccessor.ServiceLocator.ResolveByComponentId("TDNetRunner.PreferenceManager");
var reportFormat = preferenceManager.ReportSettings.DetermineReportFormat(result.Report);
result.GenerateReports(reportDirectory, Path.GetFileName(assemblyPath), ReportArchive.Normal,
new[] { reportFormat }, reportFormatterOptions,
RuntimeAccessor.ServiceLocator.Resolve <IReportManager>(), NullProgressMonitor.CreateInstance());
// This will generate a link to the generated report
if (result.ReportDocumentPaths.Count != 0)
{
Uri rawUrl = new Uri(result.ReportDocumentPaths[0]);
string displayUrl = "file:///" + rawUrl.LocalPath.Replace(" ", "%20").Replace(@"\", "/");
// TDNet just prints the link on its own but it's not always clear to users what it represents.
// testListener.TestResultsUrl(displayUrl);
testListener.WriteLine("\nTest Report: " + displayUrl, FacadeCategory.Info);
}
}
// Inform no tests run, if necessary.
if (result.ResultCode == ResultCode.NoTests)
{
InformNoTestsWereRun(testListener, Resources.MbUnitTestRunner_NoTestsFound);
}
else if (result.Statistics.TestCount == 0)
{
InformNoTestsWereRun(testListener, null);
}
return(GetTestRunState(result));
}
finally
{
RuntimeAccessor.Instance.RemoveLogListener(logger);
}
}
internal bool InternalExecute()
{
DisplayVersion();
var logger = new FilteredLogger(new TaskLogger(Log), verbosity);
var launcher = new TestLauncher();
launcher.Logger = logger;
launcher.ProgressMonitorProvider = new LogProgressMonitorProvider(logger);
launcher.TestExecutionOptions.FilterSet = GetFilterSet();
launcher.ShowReports = ShowReports;
launcher.DoNotRun = DoNotRun;
launcher.IgnoreAnnotations = IgnoreAnnotations;
launcher.RunTimeLimit = runTimeLimit;
launcher.RuntimeSetup = new RuntimeSetup();
// Set the installation path explicitly to the path of the MSBuild task assembly
// since otherwise we will look at the path of MSBuild.exe.
launcher.RuntimeSetup.RuntimePath = Path.GetDirectoryName(AssemblyUtils.GetFriendlyAssemblyLocation(typeof(Gallio).Assembly));
if (EchoResults)
{
launcher.TestProject.AddTestRunnerExtension(new TaskLogExtension(Log));
}
if (ApplicationBaseDirectory != null)
{
launcher.TestProject.TestPackage.ApplicationBaseDirectory = new DirectoryInfo(ApplicationBaseDirectory.ItemSpec);
}
if (WorkingDirectory != null)
{
launcher.TestProject.TestPackage.WorkingDirectory = new DirectoryInfo(WorkingDirectory.ItemSpec);
}
launcher.TestProject.TestPackage.ShadowCopy = ShadowCopy;
if (Debug)
{
launcher.TestProject.TestPackage.DebuggerSetup = new DebuggerSetup();
}
if (RuntimeVersion != null)
{
launcher.TestProject.TestPackage.RuntimeVersion = RuntimeVersion;
}
foreach (string option in ReportFormatterProperties)
{
KeyValuePair <string, string> pair = StringUtils.ParseKeyValuePair(option);
launcher.ReportFormatterOptions.AddProperty(pair.Key, pair.Value);
}
foreach (string option in RunnerProperties)
{
KeyValuePair <string, string> pair = StringUtils.ParseKeyValuePair(option);
launcher.TestRunnerOptions.AddProperty(pair.Key, pair.Value);
}
ForEachItemSpec(Files, launcher.AddFilePattern);
ForEachItemSpec(HintDirectories, x => launcher.TestProject.TestPackage.AddHintDirectory(new DirectoryInfo(x)));
ForEachItemSpec(PluginDirectories, x => launcher.RuntimeSetup.AddPluginDirectory(x));
if (ReportDirectory != null)
{
launcher.TestProject.ReportDirectory = ReportDirectory.ItemSpec;
}
if (ReportNameFormat != null)
{
launcher.TestProject.ReportNameFormat = ReportNameFormat;
}
if (ReportTypes != null)
{
GenericCollectionUtils.ForEach(ReportTypes, launcher.AddReportFormat);
}
if (ReportArchive != null)
{
launcher.TestProject.ReportArchive = Runner.Reports.ReportArchive.Parse(ReportArchive);
}
if (RunnerType != null)
{
launcher.TestProject.TestRunnerFactoryName = RunnerType;
}
if (RunnerExtensions != null)
{
GenericCollectionUtils.ForEach(RunnerExtensions, x => launcher.TestProject.AddTestRunnerExtensionSpecification(x));
}
TestLauncherResult result = RunLauncher(launcher);
ExitCode = result.ResultCode;
LogResultSummary(logger, result);
PopulateStatistics(result);
return(ExitCode == ResultCode.Success ||
ExitCode == ResultCode.NoTests ||
IgnoreFailures);
}
