protected override void ShowHelp() { // Show argument only help first because what we do next might take a little while // and we want to make the program appear responsive. base.ShowHelp(); // Print out options related to the currently available set of plugins. var setup = new RuntimeSetup(); if (Arguments != null && Arguments.PluginDirectories != null) { GenericCollectionUtils.ForEach(Arguments.PluginDirectories, x => setup.AddPluginDirectory(x)); } using (RuntimeBootstrap.Initialize(setup, CreateLogger())) { IReportManager reportManager = RuntimeAccessor.ServiceLocator.Resolve <IReportManager>(); ShowRegisteredComponents("Supported report types:", reportManager.FormatterHandles, h => h.GetTraits().Name, h => h.GetTraits().Description); ITestRunnerManager runnerManager = RuntimeAccessor.ServiceLocator.Resolve <ITestRunnerManager>(); ShowRegisteredComponents("Supported runner types:", runnerManager.TestRunnerFactoryHandles, h => h.GetTraits().Name, h => h.GetTraits().Description); } }
/// <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); }
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); }
static void Main(string[] args) { var settings = ConfigurationManager.AppSettings; string enterprise = settings["enterprise"]; string user = settings["username"]; string pwd = settings["password"]; var rb = RuntimeBootstrap.GetTheOnlyBootstrap(settings["hosting"], settings["registry"]); Hashtable creds = new Hashtable(4); creds.Add(AuthenticationParameters.ENTERPRISENAME, enterprise); creds.Add(AuthenticationParameters.REALM, "BizAPP"); creds.Add(AuthenticationParameters.USERNAME, user); creds.Add(AuthenticationParameters.PASSWORD, pwd); try { using (var session = rb.GetSession(creds, NetworkInformation.Current, BizAPP.Runtime.Core.Service.Session.SessionMode.Client)) { // do your stuff here } } catch (Exception ex) { Console.WriteLine(ExceptionUtils.CaptureCompleteException(ex)); } }
public void Shutdown() { if (initializedRuntime) { initializedRuntime = false; RuntimeBootstrap.Shutdown(); } }
public void Initialize(RuntimeSetup runtimeSetup, ILogger logger) { if (!RuntimeAccessor.IsInitialized) { RuntimeBootstrap.Initialize(runtimeSetup, logger); initializedRuntime = true; } }
/// <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 = new RuntimeSetup { RuntimePath = Path.GetDirectoryName(AssemblyUtils.GetFriendlyAssemblyLocation( typeof(IcarusProgram).Assembly)) }; var runtimeLogger = new RuntimeLogger(); GenericCollectionUtils.ForEach(Arguments.PluginDirectories, runtimeSetup.AddPluginDirectory); using (RuntimeBootstrap.Initialize(runtimeSetup, runtimeLogger)) { // wire up services & components var scanner = new DefaultConventionScanner(RuntimeAccessor.Registry); scanner.Scan("Gallio.Icarus", Assembly.GetExecutingAssembly()); LoadPackages(); var optionsController = RuntimeAccessor.ServiceLocator.Resolve <IOptionsController>(); // create & initialize a test runner whenever the test runner factory is changed optionsController.TestRunnerFactory.PropertyChanged += (s, e) => ConfigureTestRunnerFactory(optionsController.TestRunnerFactory); ConfigureTestRunnerFactory(optionsController.TestRunnerFactory); var runtimeLogController = RuntimeAccessor.ServiceLocator.Resolve <IRuntimeLogController>(); runtimeLogController.SetLogger(runtimeLogger); var applicationController = RuntimeAccessor.ServiceLocator.Resolve <IApplicationController>(); applicationController.Arguments = Arguments; ErrorDialogUnhandledExceptionHandler.RunApplicationWithHandler(new Main(applicationController)); UnloadPackages(); } return(ResultCode.Success); }
public static void Main() { using (TextWriter tw = new StreamWriter("RunTests.log")) { var logger = new TextLogger(tw); RuntimeBootstrap.Initialize(new RuntimeSetup(), logger); TestLauncher launcher = new TestLauncher(); launcher.AddFilePattern("RunTests.exe"); TestLauncherResult result = launcher.Run(); Console.WriteLine(result.ResultSummary); } }
public static void SetupRuntime(string runtimePath) { if (runtimePath == null) { throw new ArgumentNullException("runtimePath"); } if (!RuntimeAccessor.IsInitialized) { var setup = new RuntimeSetup(); setup.RuntimePath = runtimePath; RuntimeBootstrap.Initialize(setup, null); } }
private IDisposable InitializeRuntimeIfNeeded(ref bool canceled) { IDisposable result = null; if (RuntimeSetup != null && !RuntimeAccessor.IsInitialized) { RunWithProgress(progressMonitor => { progressMonitor.BeginTask("Initializing the runtime and loading plugins.", 1); result = RuntimeBootstrap.Initialize(RuntimeSetup, logger); }, ref canceled); } return(result); }
protected override void ShowHelp() { // Show argument only help first because what we do next might take a little while // and we want to make the program appear responsive. base.ShowHelp(); // Print out options related to the currently available set of plugins. var setup = new RuntimeSetup(); using (RuntimeAccessor.IsInitialized ? null : RuntimeBootstrap.Initialize(setup, CreateLogger())) { IUtilityCommandManager utilityCommandManager = RuntimeAccessor.ServiceLocator.Resolve <IUtilityCommandManager>(); ShowRegisteredComponents("Supported utility commands:", utilityCommandManager.CommandHandles, h => h.GetTraits().Name, h => h.GetTraits().Description); } }
public Runner() { // Create a runtime setup. // There are a few things you can tweak here if you need. _setup = new Gallio.Runtime.RuntimeSetup(); //_setup.RuntimePath = @"C:\Users\ack\bin\GallioBundle-3.2.750.0\bin"; // @"C:\Users\ack\bin\Gallio2"; //Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); //@"C:\Users\ack\bin\GallioBundle-3.2.750.0\bin"; var binPath = new BinPathLocator().Locate(); _isInitialized = File.Exists(Path.Combine(binPath, "Gallio.dll")); if (!_isInitialized) { return; } _setup.RuntimePath = binPath; //@"C:\Users\ack\src\AutoTest.Net\lib\Gallio"; // Create a logger. // You can use the NullLogger but you will probably want a wrapper around your own ILogger thingy. _logger = Gallio.Runtime.Logging.NullLogger.Instance; // Initialize the runtime. // You only do this once. lock (_gallioLock) { if (!_runtimeInitialized) { RuntimeBootstrap.Initialize(_setup, _logger); _runtimeInitialized = true; } } // Create a test framework selector. // This is used by Gallio to filter the set of frameworks it will support. // You can set a predicate Filter here. I've hardcoded MbUnit here but you could leave the filter out and set it to null. // The fallback mode tells Gallio what to do if it does not recognize the test framework associated with the test assembly. // Strict means don't do anything. You might want to use Default or Approximate. See docs. // You can also set options, probably don't care. var testFrameworkSelector = new TestFrameworkSelector() { Filter = testFrameworkHandle => testFrameworkHandle.Id == "MbUnit.TestFramework", FallbackMode = TestFrameworkFallbackMode.Strict }; // Now we need to get a suitably configured ITestDriver... var testFrameworkManager = RuntimeAccessor.ServiceLocator.Resolve <ITestFrameworkManager>(); _testDriver = testFrameworkManager.GetTestDriver(testFrameworkSelector, _logger); }
/// <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 void Initialize(RuntimeSetup runtimeSetup, ILogger logger) { RuntimeBootstrap.Initialize(runtimeSetup, logger); }
/// <inheritdoc /> protected override int RunImpl(string[] args) { ShowBanner(); InstallCancelHandler(); if (!ParseArguments(args) || Arguments.CommandAndArguments.Length == 0) { ShowHelp(); return(Arguments.Help ? 0 : 1); } ILogger logger = CreateLogger(); IProgressMonitorProvider progressMonitorProvider = Arguments.NoProgress ? (IProgressMonitorProvider)NullProgressMonitorProvider.Instance : new RichConsoleProgressMonitorProvider(Console); string commandName = Arguments.CommandAndArguments[0]; string[] commandRawArguments = new string[Arguments.CommandAndArguments.Length - 1]; Array.Copy(Arguments.CommandAndArguments, 1, commandRawArguments, 0, commandRawArguments.Length); IUtilityCommand command = GetSpecialCommand(commandName); bool isSpecialCommand = command != null; var runtimeSetup = new RuntimeSetup(); GenericCollectionUtils.ForEach(Arguments.PluginDirectories, x => runtimeSetup.AddPluginDirectory(x)); using (isSpecialCommand ? null : RuntimeBootstrap.Initialize(runtimeSetup, logger)) { if (command == null) { var commandManager = RuntimeAccessor.ServiceLocator.Resolve <IUtilityCommandManager>(); command = commandManager.GetCommand(commandName); if (command == null) { ShowErrorMessage(string.Format("Unrecognized utility command name: '{0}'.", commandName)); ShowHelp(); return(1); } } Type commandArgumentsClass = command.GetArgumentClass(); var commandArgumentParser = new CommandLineArgumentParser(commandArgumentsClass, null); if (Arguments.Help) { ShowHelpForParticularCommand(commandName, commandArgumentParser); return(0); } object commandArguments = Activator.CreateInstance(commandArgumentsClass); if (!commandArgumentParser.Parse(commandRawArguments, commandArguments, ShowErrorMessage) || !command.ValidateArguments(commandArguments, ShowErrorMessage)) { ShowHelpForParticularCommand(commandName, commandArgumentParser); return(1); } var commandContext = new UtilityCommandContext(commandArguments, Console, logger, progressMonitorProvider, Arguments.Verbosity); return(command.Execute(commandContext)); } }