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;
}
}
