private static void ListTests(string directoryToSearch) { using (ITestEngine testEngine = TestEngineActivator.CreateInstance()) { Console.WriteLine("In test engine instance"); var files = Directory.GetFiles(directoryToSearch, "*.dll", SearchOption.AllDirectories); Console.WriteLine($"Found {files.Count()} to search"); TestPackage package = new TestPackage(files); Console.WriteLine("Test package created"); using (ITestRunner runner = testEngine.GetRunner(package)) { Console.WriteLine("In runner"); var testSuites = runner.Explore(TestFilter.Empty); var testCases = testSuites.SelectNodes("//test-case"); foreach (XmlNode n in testCases) { Console.WriteLine(n.Attributes["fullname"].Value); } } } }
/// <summary> /// Run the test suite in the given project (dll and project name) with /// the configured TestFilterWhere. For the Where syntax, see /// NUnit.Engine.TestSelectionParser.ParseFilterElement() /// </summary> /// <param name="testproject"></param> public void Run(string testproject) { if (HttpContext.Current == null) { throw new InvalidOperationException("IE tests must run in the w3wp.exe address space"); } // To avoid a cyclic project dependency, the test DLL must be read // from an explicit path in the file system, but in .NET Framework, // it doesn't need to be formally referenced. var approot = HttpContext.Current.Server.MapPath("~"); var dll = Path.Combine(approot, @"..\bin", testproject + ".dll"); var package = new TestPackage(dll); // NUnit.EnginePackageSettings package.AddSetting("ProcessModel", "Single"); package.AddSetting("DomainUsage", "None"); using (var engine = TestEngineActivator.CreateInstance()) using (var runner = engine.GetRunner(package)) { var filter = TestFilter.Empty; var where = ConfigurationManager.AppSettings["TestFilterWhere"]; if (!String.IsNullOrWhiteSpace(where)) { var builder = new TestFilterBuilder(); builder.SelectWhere(where); filter = builder.GetFilter(); // returns TestFilter.Empty when no TestFilterWhere is given } TestRunnerBase.Result = runner.Run(this, filter); } }
public static void Main(string[] args) { var path = Assembly.GetExecutingAssembly().Location; var package = new TestPackage(path); package.AddSetting("WorkDirectory", Environment.CurrentDirectory); using (ITestEngine engine = TestEngineActivator.CreateInstance()) { var filterService = engine.Services.GetService <ITestFilterService>(); var builder = filterService.GetTestFilterBuilder(); var testPlan = getTestPlan(); if (testPlan != null) { foreach (var testCase in testPlan.Tests) { builder.AddTest(testCase.Selector); } } var filter = builder.GetFilter(); using (ITestRunner runner = engine.GetRunner(package)) { runner.Run(listener: null, filter: filter); } } }
private ITestRunner getRunner() { var engine = TestEngineActivator.CreateInstance(); var package = new TestPackage(_assemblyPath); return(engine.GetRunner(package)); }
public void InitializeTestEngineResult() { // Save the local directory - used by GetLocalPath Uri uri = new Uri(Assembly.GetExecutingAssembly().CodeBase); localDirectory = Path.GetDirectoryName(uri.LocalPath); AssemblyPath = GetLocalPath(AssemblyName); // Create a fresh copy of the engine, since we can't use the // one that is running this test. engine = TestEngineActivator.CreateInstance(); engine.InternalTraceLevel = InternalTraceLevel.Off; // Create a new DefaultAssemblyRunner, which is actually a framework class, // because we can't use the one that's currently running this test. var runner = new Runner(new Builder()); var settings = new Dictionary <string, object>(); // Make sure the runner loaded the mock assembly. Assert.That( runner.Load(AssemblyPath, settings).RunState.ToString(), Is.EqualTo("Runnable"), "Unable to load mock-assembly.dll"); // Run the tests, saving the result as an XML string var xmlText = runner.Run(TestListener.NULL, TestFilter.Empty).ToXml(true).OuterXml; // Create a TestEngineResult from the string, just as the TestEngine does, // then add a test-run element to the result, wrapping the result so it // looks just like what the engine would return! this.EngineResult = new TestEngineResult(xmlText).Aggregate("test-run", AssemblyName, AssemblyPath); }
public override async Task RunTestsAsync(CancellationToken token, HashSet <string> tests = null) { // Get an interface to the engine using var engine = TestEngineActivator.CreateInstance(); engine.WorkDirectory = new FileInfo(TestProjectAssemblyPath).DirectoryName; // Create a simple test package - one assembly, no special settings var package = new TestPackage(TestProjectAssemblyPath); foreach (var setting in Settings) { package.AddSetting(setting.Key, setting.Value); } // Get a runner for the test package using var runner = engine.GetRunner(package); try { var run = runner.RunAsync(new NUnitEventListener(this), GetTestFilter(tests)); await Task.Run(() => { run.Wait(Timeout.Infinite); }, token); } finally { runner.Dispose(); engine.Dispose(); } }
/// <summary> /// Creates an instance of the NUnitTestCounter given the assembly path /// </summary> /// <param name="assemblyPath"></param> public NUnitTestCounter(string assemblyPath, bool verbose = false) { var engine = TestEngineActivator.CreateInstance(); var package = new TestPackage(assemblyPath); Runner = engine.GetRunner(package); Verbose = verbose; }
public void RunTests() { ITestEngine engine = TestEngineActivator.CreateInstance(); var package = new TestPackage(TestAssemblyPath); ITestRunner runner = engine.GetRunner(package); runner.Run(NunitListener, TestFilter.Empty); }
public UnitTestEngine() { if (internalITestEngine == null) { internalITestEngine = TestEngineActivator.CreateInstance(true); } TestEngine = internalITestEngine; }
private static void Main(string[] args) { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); CommandLineOptions options = new CommandLineOptions(); try { options.Parse(args); } catch (OptionException ex) { string msg = string.Format("{0} {1}", ex.Message, ex.OptionName); MessageBox.Show(msg, "NUnit - OptionException", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } if (options.ShowHelp) { ShowHelpText(options); return; } var testEngine = TestEngineActivator.CreateInstance(true); if (options.InternalTraceLevel != null) { testEngine.InternalTraceLevel = (InternalTraceLevel)Enum.Parse(typeof(InternalTraceLevel), options.InternalTraceLevel); } var model = new TestModel(testEngine, options); var form = new MainForm(); MainPresenter mp = new MainPresenter(form, model); form.mp = mp; new ProgressBarPresenter(form.ProgressBarView, model); new TreeViewPresenter(form.TestTreeView, model); new StatusBarPresenter(form.StatusBarView, model); new TestPropertiesPresenter(form.PropertiesView, model); new XmlPresenter(form.XmlView, model); //new RecentFiles(settingsServiceServiceService._settings); //new RecentFilesPresenter(form, settingsServiceServiceService); try { Application.Run(form); } finally { testEngine.Dispose(); } }
public void CreateTestModel() { var engine = TestEngineActivator.CreateInstance(); Assert.NotNull(engine, "Unable to create engine instance for testing"); _model = new TestModel(engine, new CommandLineOptions()); _model.LoadTests(new[] { Path.Combine(TestContext.CurrentContext.TestDirectory, MOCK_ASSEMBLY) }); }
public TestDriver(string path) { TestPackage package = new TestPackage(path); ITestEngine engine = TestEngineActivator.CreateInstance(); var _filterService = engine.Services.GetService <ITestFilterService>(); ITestFilterBuilder builder = _filterService.GetTestFilterBuilder(); EmptyFilter = builder.GetFilter(); TestRunner = engine.GetRunner(package); }
public void CreateTestModel() { var engine = TestEngineActivator.CreateInstance(); Assert.NotNull(engine, "Unable to create engine instance for testing"); _model = new TestModel(engine); _model.LoadTests(new TestPackage(MOCK_ASSEMBLY)); }
public void Initialize() { #if NET35 var engineX = new TestEngine(); #else var engineX = TestEngineActivator.CreateInstance(); #endif InternalEngineCreated?.Invoke(engineX); TestEngine = engineX; }
public void CreateTestModel() { var engine = TestEngineActivator.CreateInstance(); Assert.NotNull(engine, "Unable to create engine instance for testing"); _model = new TestModel(engine, new CommandLineOptions()); _model.LoadTests(new [] { MOCK_ASSEMBLY }); }
public static XmlNode DoWork(string assemblyName) { var assembly = AssemblyLoadContext.Default.Assemblies.First(x => x.GetName().Name == assemblyName); ITestEngine engine = TestEngineActivator.CreateInstance(); TestPackage package = new TestPackage(assembly.Location); package.Settings[FrameworkPackageSettings.RunOnMainThread] = true; ITestRunner runner = engine.GetRunner(package); return(runner.Run(Listener, TestFilter.Empty)); }
public void CreateTestModel() { var engine = TestEngineActivator.CreateInstance(); Assert.NotNull(engine, "Unable to create engine instance for testing"); var model = new TestModel(engine, new CommandLineOptions()); _availableRuntimes = model.AvailableRuntimes; Assert.NotNull(_availableRuntimes); }
[Test, Platform("Net")] //TODO: Make test work on .NET Core. Tracked as https://github.com/nunit/nunit-console/issues/946 public void CanInstantiateEngineInsideTest() { Assert.DoesNotThrow(() => { using (var engine = TestEngineActivator.CreateInstance()) { var mockAssemblyPath = Path.Combine(TestContext.CurrentContext.TestDirectory, "mock-assembly.dll"); var package = new TestPackage(mockAssemblyPath); engine.GetRunner(package).Run(new NullListener(), TestFilter.Empty); } }); }
public static TestResults Run(HostedOptions options, Messages.OnMessage[] messageSubscribers) { using (ITestEngine engine = TestEngineActivator.CreateInstance()) { if (options.WorkDirectory != null) { engine.WorkDirectory = options.WorkDirectory; } return(new Runner(engine, options).Execute(messageSubscribers)); } }
private TestSuite GetTestSuite(TestPackage testPackage) { using (var engine = TestEngineActivator.CreateInstance()) { using (var runner = engine.GetRunner(testPackage)) { var xml = runner.Explore(TestFilter.Empty); var json = xml.ToJson(); var nUnitJsonParser = new NUnitJsonParser(); return(nUnitJsonParser.GetTestSuiteFromDiscoveryJson(json)); } } }
static void Main(string[] args) { ITestEngine engine = TestEngineActivator.CreateInstance(); ITestFilterService _filterService = engine.Services.GetService <ITestFilterService>(); TestPackage package = new TestPackage(Assembly.GetExecutingAssembly().Location); package.AddSetting("WorkDirectory", Environment.CurrentDirectory); using (ITestRunner runner = engine.GetRunner(package)) { ITestFilterBuilder builder = _filterService.GetTestFilterBuilder(); XmlNode result = runner.Run(null, builder.GetFilter()); } }
public async Task <List <TestResult> > RunTestCase(TestPackage testPackage, string name = "") { using (var engine = TestEngineActivator.CreateInstance()) { using (var runner = engine.GetRunner(testPackage)) { await Task.Delay(1); //Just to make sure we can have awaitable var filter = TestFilter(engine, name); var x = runner.Run(new TestEventListener(), filter); return(GetTestResults(x.ToJson())); } } }
private static async Task MainAsync(string[] args) { var options = new RunnerOptions(); try { options = OptionsParser.ParseOptions(args); } catch (OptionException e) { Console.WriteLine(e.Message); Console.WriteLine("Try running with '--help' for more information."); Environment.Exit(1); } var engine = TestEngineActivator.CreateInstance(true); var package = new TestPackage(options.TargetAssembly); var reportItems = new ConcurrentQueue <ReportItem>(); var testEventListener = new TestEventListener(engine, package, reportItems, string.Empty); var testCount = testEventListener.Runner.CountTestCases(TestFilter.Empty); if (testCount == 0) { throw new ArgumentException("Nothing to run, no tests were loaded"); } var userStepTime = options.RampUp / options.Concurrency; var reportWriter = new ReportWriter(reportItems); var reportWriterTask = Task.Run(() => reportWriter.StartWriting(options.ReportFile)); var startTime = DateTime.UtcNow; var testTasks = new Task[options.Concurrency]; for (int i = 0; i < options.Concurrency; i++) { var threadName = "worker_" + (i + 1); testTasks[i] = Task.Run(() => Test.RunTest( startTime, options, new TestEventListener(engine, package, reportItems, threadName))); Thread.Sleep(userStepTime * 1000); } await Task.WhenAll(testTasks); reportWriter.TestsCompleted = true; await reportWriterTask; }
private static async Task Handler(int iterations, int duration, int concurrency, int rampUp, string reportFile, string target) { if (string.IsNullOrEmpty(target)) { throw new ArgumentException("Nothing to run, no tests library provided"); } var testAssembly = System.Reflection.Assembly.LoadFrom(target); var engine = TestEngineActivator.CreateInstance(); var package = new TestPackage(target); var runner = engine.GetRunner(package); var testCount = runner.CountTestCases(TestFilter.Empty); if (testCount == 0) { throw new ArgumentException("Nothing to run, no tests were loaded"); } var reportWriter = new ReportWriter(reportFile); var userStepTime = rampUp / concurrency; var testTasks = new List <Task>(); var startTime = DateTime.UtcNow; for (var i = 1; i <= concurrency; ++i) { var threadName = $"worker_{i}"; var runnerForThread = engine.GetRunner(package); testTasks.Add(Task.Run(() => StartWorker( runnerForThread, new NUnitTestEventListener(reportWriter, threadName), startTime, iterations, duration) ) ); Thread.Sleep(userStepTime * 1000); } await Task.WhenAll(testTasks); await reportWriter.StopWritingAsync(); }
public static void Main(string[] args) { RunnerOptions opts = null; try { opts = ParseOptions(args); } catch (OptionException e) { Console.WriteLine(e.Message); Console.WriteLine("Try running with '--help' for more information."); Environment.Exit(1); } RecordingListener listener = new RecordingListener(opts.reportFile); ITestEngine engine = TestEngineActivator.CreateInstance(); TestPackage package = new TestPackage(opts.targetAssembly); ITestRunner runner = engine.GetRunner(package); int testCount = runner.CountTestCases(TestFilter.Empty); if (testCount < 1) { throw new ArgumentException("Nothing to run, no tests were loaded"); } try { DateTime startTime = DateTime.Now; for (int i = 0; i < opts.iterations; i++) { runner.Run(listener, TestFilter.Empty); TimeSpan offset = DateTime.Now - startTime; if (opts.durationLimit > 0 && offset.TotalSeconds > opts.durationLimit) { break; } } } finally { listener.CloseFile(); } Environment.Exit(0); }
public void RunTests() { ITestEngine engine = TestEngineActivator.CreateInstance(); TestSuite mTestSuite = null; ITestEventListener listner = null; //EventListener li = new NullListener(); Console.WriteLine("Created amazonSqsClient"); Console.WriteLine("App Config path:" + AppDomain.CurrentDomain.SetupInformation.ConfigurationFile); var message = testQueue.Get(); if (message == null) return; // if count greater than 3 then delete message if (int.Parse(message.Attributes["ApproximateReceiveCount"]) > 3) testQueue.DeleteMessage(queue.QueueUrl, message.ReceiptHandle); var testmodel = JsonConvert.DeserializeObject<TestModel>(message.Body); Environment.SetEnvironmentVariable("env.testConfig", JsonConvert.SerializeObject(testmodel.ConfigModel)); // if test assembly does not exists delete message if(File.Exists(testmodel.ConfigModel.TestAssembly)) testQueue.DeleteMessage(message); TestPackage package = TestPackage(testmodel.ConfigModel.TestAssembly); AppConfig.Change(package.FullName + ".config"); TestPackage package = new TestPackage(testmodel.ConfigModel.TestAssembly); mTestSuite = new TestSuiteBuilder().Build(package); amazonSqsClient.DeleteMessage(queue.QueueUrl, message.ReceiptHandle); Console.WriteLine("-> starting tests ...."); Console.WriteLine("-> Tests:" + testmodel.ConfigModel.TestAssembly); Console.WriteLine("-> Category:" + testmodel.Category); ITestFilter testFilter = new CategoryFilter(testmodel.Category); ITestRunner runner = engine.GetRunner(package); XmlNode result = runner.Run(, testFilter); TestResult result = mTestSuite.Run(li, testFilter); Thread.Sleep(5000); }
static void Main(string[] args) { using (ITestEngine testEngine = TestEngineActivator.CreateInstance()) { var files = Directory.GetFiles(ConfigurationManager.AppSettings["directoryToSearch"], "*.dll", SearchOption.AllDirectories); TestPackage package = new TestPackage(files); using (ITestRunner runner = testEngine.GetRunner(package)) { var testSuites = runner.Explore(TestFilter.Empty); var testCases = testSuites.SelectNodes("//test-case"); foreach (XmlNode n in testCases) { Console.WriteLine(n.Attributes["fullname"].Value); } } } }
/// <summary> /// Run the tests. /// </summary> /// <param name="commandLineOptions"></param> /// <returns></returns> /// <exception cref="CommandLineArgumentException"> /// One or more arguments on the command line were invalid. /// </exception> public static int OnRunTests(CommandLineOptions commandLineOptions) { TestEventListener testEventListener; try { ApiBestPracticeTestBase.Register( File.ReadAllText(commandLineOptions.SwaggerFilePath), commandLineOptions.BaseUrl != null ? new Uri(commandLineOptions.BaseUrl) : null); } catch (IOException ex) { throw new CommandLineArgumentException( $"Swagger file '{commandLineOptions.SwaggerFilePath}' does not exist or cannot be read", ex); } catch (UnauthorizedAccessException ex) { throw new CommandLineArgumentException( $"Swagger file '{commandLineOptions.SwaggerFilePath}' cannot be accessed", ex); } catch (UriFormatException ex) { throw new CommandLineArgumentException( $"Base URL '{commandLineOptions.BaseUrl}' is not a valid URI", ex); } testEventListener = new TestEventListener(); testEventListener.OnTestCaseResult += TestEventListener_OnTestCaseResult; FailedTestCount = 0; ApiBestPracticeTestBase.Register( File.ReadAllText(commandLineOptions.SwaggerFilePath), commandLineOptions.BaseUrl != null ? new Uri(commandLineOptions.BaseUrl) : null); using (ITestEngine engine = TestEngineActivator.CreateInstance()) using (ITestEngineRunner testRunner = new LocalTestRunner(engine.Services, new TestPackage("jab.dll"))) { testRunner.Run(testEventListener, TestFilter.Empty); } return(FailedTestCount > 0 ? ExitCodes.TestFailed : ExitCodes.Success); }
static void Main(string[] args) { // set up the options string path = Assembly.GetExecutingAssembly().Location; TestPackage package = new TestPackage(path); package.AddSetting("WorkDirectory", Environment.CurrentDirectory); // prepare the engine ITestEngine engine = TestEngineActivator.CreateInstance(); var _filterService = engine.Services.GetService <ITestFilterService>(); ITestFilterBuilder builder = _filterService.GetTestFilterBuilder(); TestFilter emptyFilter = builder.GetFilter(); using (ITestRunner runner = engine.GetRunner(package)) { // execute the tests XmlNode result = runner.Run(null, emptyFilter); } }
protected void Page_Load(object sender, EventArgs e) { // set up the options string path = Assembly.GetExecutingAssembly().Location; TestPackage package = new TestPackage(path); package.AddSetting("ProcessModel", "Single"); package.AddSetting("DomainUsage", "None"); // prepare the engine ITestEngine engine = TestEngineActivator.CreateInstance(); var _filterService = engine.Services.GetService <ITestFilterService>(); ITestFilterBuilder builder = _filterService.GetTestFilterBuilder(); TestFilter emptyFilter = builder.GetFilter(); using (ITestRunner runner = engine.GetRunner(package)) { // execute the tests XmlNode result = runner.Run(null, emptyFilter); lblTest.Text = result.InnerText; } }