public void Run(XunitTestAssemblyTask assemblyTask, TaskProvider taskProvider) { var priorCurrentDirectory = Environment.CurrentDirectory; try { // Use the assembly in the folder that the user has specified, or, if not, use the assembly location var assemblyFolder = GetAssemblyFolder(configuration, assemblyTask); var assemblyPath = Path.Combine(assemblyFolder, GetFileName(assemblyTask.AssemblyLocation)); Environment.CurrentDirectory = assemblyFolder; // If we just pass null for the config file, the AppDomain will load {assembly}.config if it exists, // or use the config file of this app domain, which will usually be JetBrains.ReSharper.TaskRunner.*.exe.config. // If we specify the name directly, it will just use it, or have no configuration, with no fallback. // This is good because it stops the TaskRunner.exe config leaking into your tests. For example, that // file redirects all ReSharper assemblies to the current version. When the default AppDomain loads our // code, the assemblies are successfully redirected, and we use the latest version. If the new AppDomain // uses the same redirects, and the test assembly references resharper assemblies (e.g. xunitcontrib tests!) // the redirects are applied, but the new AppDomain can't find the newer assemblies, and throws var configFile = assemblyPath + ".config"; using (var executorWrapper = new ExecutorWrapper(assemblyPath, configFile, configuration.ShadowCopy)) { SetTempFolderPath(executorWrapper); var run = new XunitTestRun(server, executorWrapper, taskProvider); run.RunTests(); } } finally { Environment.CurrentDirectory = priorCurrentDirectory; } }
/// <summary> /// Runs the specified test. /// </summary> /// <param name="className"></param> /// <param name="methodName"></param> /// <returns>True to indicate success, false to indicate fail</returns> public static bool RunExampleTest(string className, string methodName) { using (MockAssembly assembly = new MockAssembly()) { XmlNode lastNode = null; XmlNode returnValue = null; using (ExecutorWrapper wrapper = new ExecutorWrapper("Coulda.Examples.dll", null, false)) { returnValue = wrapper.RunTest(className, methodName, node => { lastNode = node; return true; }); } XmlNode resultNode = ResultXmlUtility.GetResult(lastNode); //ResultXmlUtility.AssertAttribute(resultNode, "result", "Pass"); if(resultNode.Attributes["result"].Value == "Pass") { return true; } } return false; }
static void Run(string className, System.Reflection.Assembly koanAssembly, ExecutorWrapper wrapper) { Type classToRun = koanAssembly.GetType(className); if (classToRun == null) { return; } string[] queue = new string[classToRun.GetMethods().Length + 1]; int highestKoanNumber = 0; foreach (MethodInfo method in classToRun.GetMethods()) { if (method.Name == null) { continue; } DotNetKoans.KoanAttribute custAttr = method.GetCustomAttributes(typeof(DotNetKoans.KoanAttribute), false).FirstOrDefault() as DotNetKoans.KoanAttribute; if (custAttr == null) { continue; } queue[custAttr.Position] = method.Name; if (custAttr.Position > highestKoanNumber) { highestKoanNumber = custAttr.Position; } } int numberOfTestsActuallyRun = 0; foreach (string test in queue) { if (String.IsNullOrEmpty(test)) { continue; } numberOfTestsActuallyRun += 1; if (TEST_FAILED != 0) { continue; } wrapper.RunTest(className, test, callback); } if (numberOfTestsActuallyRun != highestKoanNumber) { Console.WriteLine("!!!!WARNING - Some Koans appear disabled. The highest koan found was {0} but we ran {1} koan(s)", highestKoanNumber, numberOfTestsActuallyRun); } }
private static void Main(string[] args) { var exeWrapper = new ExecutorWrapper(Assembly.GetExecutingAssembly().Location, null, true); var builder = TestAssemblyBuilder.Build(exeWrapper); Console.WriteLine("AutoMapper Inheritance Extension Sample\n\n"); builder.Run(builder.EnumerateTestMethods(), new TestRunnerCallback()); }
static int Main(string[] args) { try { Console.WriteLine(""); Console.WriteLine(""); Console.WriteLine("*******************************************************************"); Console.WriteLine("*******************************************************************"); if (args.Length == 0) { Console.WriteLine("Need to pass as argument the path to test DLL (CSharp.dll)"); return TEST_FAILED; } else { string koan_path = args[0]; Xunit.ExecutorWrapper wrapper = new ExecutorWrapper(koan_path, null, false); System.Reflection.Assembly koans = System.Reflection.Assembly.LoadFrom(koan_path); if (koans == null) { Console.WriteLine("Bad Assembly"); return -1; } Type pathType = null; foreach (Type type in koans.GetExportedTypes()) { if (typeof(KoanHelpers.IAmThePathToEnlightenment).IsAssignableFrom(type)) { pathType = type; break; } } KoanHelpers.IAmThePathToEnlightenment path = Activator.CreateInstance(pathType) as KoanHelpers.IAmThePathToEnlightenment; string[] thePath = path.ThePath; foreach (string koan in thePath) { Run(koan, koans, wrapper); } } } catch (Exception ex) { Console.WriteLine("Karma has killed the runner. Exception was: " + ex.ToString()); //return -1; return TEST_FAILED; } Console.WriteLine("*******************************************************************"); Console.WriteLine("*******************************************************************"); Console.WriteLine(""); Console.WriteLine(""); // Add prompt so you can view the console results Console.WriteLine("Press <Enter> to continue, because \"like gravity, karma is so basic"); Console.WriteLine("we often don't even notice it.\" - Sakyong Mipham"); Console.ReadLine(); return TEST_FAILED; }
public SessionResults RunAssembly(Assembly assembly) { var sessionResults = new SessionResults(); var logger = new GilesXunitLogger(); using (var exWrapper = new XunitFx.ExecutorWrapper(new Uri(assembly.CodeBase).LocalPath, null, false)) { var runner = new XunitFx.TestRunner(exWrapper, logger); var result = runner.RunAssembly(); } return logger.SessionResults; }
/// <summary> /// Run all the unit tests in the class /// </summary> /// <param name="assemblyPath">The assembly that contains the unit test.</param> /// <param name="className">The full name of the class that contains the unit test.</param> override public void RunTests(string assemblyPath, string assemblyName) { System.Xml.XmlNode returnValue = null; using (ExecutorWrapper wrapper = new ExecutorWrapper(assemblyPath, null, true)) { returnValue = wrapper.RunAssembly(node => true); } ParseResults(returnValue); }
public SessionResults RunAssembly(Assembly assembly) { var sessionResults = new SessionResults(); var logger = new GilesXunitLogger(); using (var exWrapper = new XunitFx.ExecutorWrapper(new Uri(assembly.CodeBase).LocalPath, null, false)) { var runner = new XunitFx.TestRunner(exWrapper, logger); var result = runner.RunAssembly(); } return(logger.SessionResults); }
public SessionResults RunAssembly(Assembly assembly, IEnumerable<string> filters) { var logger = new GilesXunitLogger(); using (var exWrapper = new XunitFx.ExecutorWrapper(new Uri(assembly.CodeBase).LocalPath, null, false)) { var runner = new XunitFx.TestRunner(exWrapper, logger); if (filters.Count() == 0) runner.RunAssembly(); else filters.Each(x => runner.RunClass(x)); } return logger.SessionResults; }
public void GetProviderServices_returns_null_when_unknown() { var domain = AppDomain.CreateDomain("ExecutorWrapperTests", null, AppDomain.CurrentDomain.SetupInformation); try { var executor = new ExecutorWrapper( domain, Path.GetFileName(GetType().Assembly.CodeBase)); Assert.Null(executor.GetProviderServices("My.Fake.Provider")); } finally { AppDomain.Unload(domain); } }
public void GetProviderServices_returns_null_when_no_project_assembly() { var domain = AppDomain.CreateDomain("ExecutorWrapperTests", null, AppDomain.CurrentDomain.SetupInformation); try { var executor = new ExecutorWrapper( domain, "UnknownProject.dll"); Assert.Null(executor.GetProviderServices("System.Data.SqlClient")); } finally { AppDomain.Unload(domain); } }
// Tell ReSharper the cache folder being used for shadow copy, so that if // someone kills this process (e.g. user aborts), ReSharper can delete it. // xunit doesn't expose this information, so we'll grab it via (sorry) reflection private void SetTempFolderPath(ExecutorWrapper executorWrapper) { if (!configuration.ShadowCopy) return; var fieldInfo = executorWrapper.GetType().GetField("appDomain", BindingFlags.NonPublic | BindingFlags.Instance); if (fieldInfo == null) throw new InvalidOperationException("Expected ExecutorWrapped to contain private field \"appDomain\""); var appDomain = fieldInfo.GetValue(executorWrapper) as AppDomain; if (appDomain != null) { var cachePath = appDomain.SetupInformation.CachePath; if (!string.IsNullOrEmpty(cachePath)) server.SetTempFolderPath(cachePath); } }
public void Should_be_able_to_run_the_simple_example() { using (MockAssembly assembly = new MockAssembly()) { XmlNode lastNode = null; XmlNode returnValue = null; using (ExecutorWrapper wrapper = new ExecutorWrapper("Coulda.Examples.dll", null, false)) returnValue = wrapper.RunClass("Coulda.Examples.SimpleExample", node => { lastNode = node; return true; }); XmlNode resultNode = ResultXmlUtility.GetResult(lastNode); ResultXmlUtility.AssertAttribute(resultNode, "name", "My example test should be able to assert"); ResultXmlUtility.AssertAttribute(resultNode, "type", "Coulda.Examples.SimpleExample"); ResultXmlUtility.AssertAttribute(resultNode, "method", "A_simple_example"); ResultXmlUtility.AssertAttribute(resultNode, "result", "Pass"); } }
public void GetProviderServices_returns_assembly_qualified_type_name() { var domain = AppDomain.CreateDomain("ExecutorWrapperTests", null, AppDomain.CurrentDomain.SetupInformation); try { var executor = new ExecutorWrapper( domain, Path.GetFileName(GetType().Assembly.CodeBase)); var typeName = executor.GetProviderServices("System.Data.SqlClient"); Assert.Equal(typeof(SqlProviderServices).AssemblyQualifiedName, typeName); } finally { AppDomain.Unload(domain); } }
public void Should_be_able_to_have_a_failing_test() { using (MockAssembly assembly = new MockAssembly()) { XmlNode lastNode = null; XmlNode returnValue = null; using (ExecutorWrapper wrapper = new ExecutorWrapper("Coulda.Examples.dll", null, false)) returnValue = wrapper.RunClass("Coulda.Examples.FailingExample", node => { lastNode = node; return true; }); XmlNode resultNode = ResultXmlUtility.GetResult(lastNode); ResultXmlUtility.AssertAttribute(resultNode, "name", "A test with an assertion should be able to fail"); ResultXmlUtility.AssertAttribute(resultNode, "type", "Coulda.Examples.FailingExample"); ResultXmlUtility.AssertAttribute(resultNode, "method", "A_failing_example"); ResultXmlUtility.AssertAttribute(resultNode, "result", "Fail"); } }
public SessionResults RunAssembly(Assembly assembly, IEnumerable <string> filters) { var logger = new GilesXunitLogger(); using (var exWrapper = new XunitFx.ExecutorWrapper(new Uri(assembly.CodeBase).LocalPath, null, false)) { var runner = new XunitFx.TestRunner(exWrapper, logger); if (filters.Count() == 0) { runner.RunAssembly(); } else { filters.Each(x => runner.RunClass(x)); } } return(logger.SessionResults); }
public override void ExecuteRecursive(TaskExecutionNode node) { var priorCurrentDirectory = Environment.CurrentDirectory; try { var assemblyTask = (XunitTestAssemblyTask) node.RemoteTask; var assemblyLocation = assemblyTask.AssemblyLocation; var assemblyFolder = Path.GetDirectoryName(assemblyLocation); var assemblyPath = Path.Combine(assemblyFolder, Path.GetFileName(assemblyLocation)); var config = assemblyPath + ".config"; Environment.CurrentDirectory = assemblyFolder; var shadowCopy = TaskExecutor.Configuration != null && TaskExecutor.Configuration.ShadowCopy; using (var executorWrapper = new ExecutorWrapper(assemblyLocation, config, shadowCopy)) { foreach (var childNode in node.Children) { var classTask = (XunitTestClassTask) childNode.RemoteTask; var runnerLogger = new ReSharperRunnerLogger(Server, classTask); runnerLogger.ClassStart(); var tasks = childNode.Children .Select(methodNode => (XunitTestMethodTask) methodNode.RemoteTask) .ToList(); runnerLogger.SetMethodTasks(tasks); var methodNames = tasks .Select(methodTask => methodTask.ShortName) .ToList(); new TestRunner(executorWrapper, runnerLogger).RunTests(classTask.TypeName, methodNames); runnerLogger.ClassFinished(); } } } finally { Environment.CurrentDirectory = priorCurrentDirectory; } }
static int Main(string[] args) { StringBuilder progress = new StringBuilder(); try { Console.WriteLine(""); Console.WriteLine(""); Console.WriteLine("*******************************************************************"); Console.WriteLine("*******************************************************************"); string koan_path = args[0]; Xunit.ExecutorWrapper wrapper = new ExecutorWrapper(koan_path, null, false); System.Reflection.Assembly koans = System.Reflection.Assembly.LoadFrom(koan_path); if (koans == null) { Console.WriteLine("Bad Assembly"); return -1; } Type pathType = null; foreach (Type type in koans.GetExportedTypes()) { if (typeof(KoanHelpers.IAmThePathToEnlightenment).IsAssignableFrom(type)) { pathType = type; break; } } KoanHelpers.IAmThePathToEnlightenment path = Activator.CreateInstance(pathType) as KoanHelpers.IAmThePathToEnlightenment; string[] thePath = path.ThePath; foreach (string koan in thePath) { progress.AppendFormat("{0},", Run(koan, koans, wrapper)); } } catch (Exception ex) { Console.WriteLine("Karma has killed the runner. Exception was: " + ex.ToString()); return -1; } Console.WriteLine("Koan progress:{0}", progress.ToString()); Console.WriteLine("*******************************************************************"); Console.WriteLine("*******************************************************************"); Console.WriteLine(""); Console.WriteLine(""); return TEST_FAILED; }
static void Run(string className, System.Reflection.Assembly koanAssembly, ExecutorWrapper wrapper) { Type classToRun = koanAssembly.GetType(className); if (classToRun == null) { return; } string[] queue = new string[classToRun.GetMethods().Length + 1]; foreach (MethodInfo method in classToRun.GetMethods()) { if (method.Name == null) { continue; } DotNetKoans.KoanAttribute custAttr = method.GetCustomAttributes(typeof(DotNetKoans.KoanAttribute), false).FirstOrDefault() as DotNetKoans.KoanAttribute; if (custAttr == null) { continue; } queue[custAttr.Position] = method.Name; } foreach (string test in queue) { if (String.IsNullOrEmpty(test)) { continue; } if (TEST_FAILED != 0) { continue; } wrapper.RunTest(className, test, callback); } }
public void GetProviderServices_returns_null_when_no_EntityFramework_assembly() { var domain = AppDomain.CreateDomain( "ExecutorWrapperTests", null, new AppDomainSetup { // NOTE: This will cause assembly resolution for EntityFramework to fail ApplicationBase = Path.GetTempPath() }); try { var executor = new ExecutorWrapper( domain, Path.GetFileName(GetType().Assembly.CodeBase)); Assert.Null(executor.GetProviderServices("System.Data.SqlClient")); } finally { AppDomain.Unload(domain); } }
public void AcceptanceTest() { string code = @" using Xunit; public class TestClass { [Fact] public void TestMethod1() {} [Fact] public void TestMethod2() {} [Fact] public void TestMethod3() {} }"; using (MockAssembly assembly = new MockAssembly()) { assembly.Compile(code); XmlNode lastNode = null; XmlNode returnValue = null; using (ExecutorWrapper wrapper = new ExecutorWrapper(assembly.FileName, null, false)) returnValue = wrapper.RunTests("TestClass", new List<string> { "TestMethod1", "TestMethod2" }, node => { lastNode = node; return true; }); Assert.Equal(returnValue, lastNode); Assert.Equal(2, lastNode.ChildNodes.Count); // Two test results XmlNode result0 = ResultXmlUtility.GetResult(lastNode, 0); Assert.Equal("Pass", result0.Attributes["result"].Value); XmlNode result1 = ResultXmlUtility.GetResult(lastNode, 1); Assert.Equal("Pass", result1.Attributes["result"].Value); } }
public IEnumerable<AutoTest.TestRunners.Shared.Results.TestResult> Run(RunSettings settings) { var logger = new XUnitLogger(); XunitProject project = new XunitProject(); var runner = settings.Assembly; // Set assembly externally as XUnit screws up the casing logger.SetCurrentAssembly(runner.Assembly); XunitProjectAssembly assembly = new XunitProjectAssembly { AssemblyFilename = runner.Assembly, ConfigFilename = null, ShadowCopy = false }; project.AddAssembly(assembly); foreach (XunitProjectAssembly asm in project.Assemblies) { using (ExecutorWrapper wrapper = new ExecutorWrapper(asm.AssemblyFilename, asm.ConfigFilename, asm.ShadowCopy)) { try { var xunitRunner = new TestRunner(wrapper, logger); //Run all tests if (runner.Tests.Count() == 0 && runner.Members.Count() == 0 && runner.Namespaces.Count() == 0) xunitRunner.RunAssembly(); //Run tests if (runner.Tests.Count() > 0) { foreach (var test in runner.Tests) xunitRunner.RunTest(test.Substring(0, test.LastIndexOf(".")), test.Substring(test.LastIndexOf(".") + 1, test.Length - (test.LastIndexOf(".") + 1))); } //Run members if (runner.Members.Count() > 0) { foreach (var member in runner.Members) xunitRunner.RunClass(member); } //Run namespaces if (runner.Namespaces.Count() > 0) { var loadedAssembly = Assembly.LoadFrom(runner.Assembly); var types = loadedAssembly.GetExportedTypes(); loadedAssembly = null; foreach (var ns in runner.Namespaces) { foreach (Type type in types) if (ns == null || type.Namespace == ns) xunitRunner.RunClass(type.FullName); } } } catch (ArgumentException ex) { Console.WriteLine(ex.Message); } } } return logger.Results; }
public void DoRunTests() { _isCancelRequested = false; if (Directory.Exists("./Screenshots")) { var screenshotDirectory = new DirectoryInfo("./Screenshots"); foreach (var file in screenshotDirectory.GetFiles("*.png")) { file.Delete(); } } var executingAssembly = System.Reflection.Assembly.GetExecutingAssembly(); try { using (var wrapper = new ExecutorWrapper(executingAssembly.Location, null, true)) { var assembly = TestAssemblyBuilder.Build(wrapper); var methods = assembly .EnumerateTestMethods() .ToList(); var activeMethods = methods .Where(m => _viewModel.UseFirefox && m.TestClass.TypeName.Contains("Firefox") || _viewModel.UseChrome && m.TestClass.TypeName.Contains("Chrome") || _viewModel.UseInternetExplorer && m.TestClass.TypeName.Contains("Internet") || _viewModel.UsePhantomJs && m.TestClass.TypeName.Contains("Phantom") ) .ToList(); if (activeMethods.Count > 0) { assembly.Run(activeMethods, this); } else { _eventAggregator.GetEvent<TestRunFinishedEvent>().Publish(true); _viewModel.IsRunning = false; } } } catch (Exception ex) { MessageBox.Show(ex.Message, "Error"); } finally { Application.Current.Dispatcher.BeginInvoke((Action)(DoDone)); } }
public void TestMethodWithNonTestMethod() { string code = @" using Xunit; public class TestClass { [Fact] public void TestMethod1() {} [Fact] public void TestMethod2() {} [Fact] public void TestMethod3() {} public void NonTestMethod() {} }"; using (MockAssembly assembly = new MockAssembly()) { assembly.Compile(code); XmlNode lastNode = null; using (ExecutorWrapper wrapper = new ExecutorWrapper(assembly.FileName, null, false)) wrapper.RunTests("TestClass", new List<string> { "TestMethod1", "NonTestMethod" }, node => { lastNode = node; return true; }); Assert.Single(lastNode.ChildNodes); // Only the test method XmlNode result = ResultXmlUtility.GetResult(lastNode, 0); Assert.Equal("Pass", result.Attributes["result"].Value); } }
public void NonPublicTestMethod() { string code = @" using Xunit; public class TestClass { [Fact] void NonPublicTestMethod() {} }"; using (MockAssembly assembly = new MockAssembly()) { assembly.Compile(code); XmlNode returnValue = null; using (ExecutorWrapper wrapper = new ExecutorWrapper(assembly.FileName, null, false)) returnValue = wrapper.RunTests("TestClass", new List<string> { "NonPublicTestMethod" }, node => { return true; }); Assert.Single(returnValue.ChildNodes); XmlNode result = ResultXmlUtility.GetResult(returnValue, 0); Assert.Equal("Pass", result.Attributes["result"].Value); } }
/// <inheritdoc/> public void Dispose() { ExecutorWrapper.Dispose(); }
static void Run(string className, System.Reflection.Assembly koanAssembly, ExecutorWrapper wrapper) { Type classToRun = koanAssembly.GetType(className); if (classToRun == null) { Console.WriteLine("Class {0} not found", className); } object koans = Activator.CreateInstance(classToRun); MethodInfo[] queue = new MethodInfo[classToRun.GetMethods().Length + 1]; int highestKoanNumber = 0; foreach (MethodInfo method in classToRun.GetMethods()) { if (method.Name == null) { continue; } DotNetKoans.KoanAttribute custAttr = method.GetCustomAttributes(typeof(DotNetKoans.KoanAttribute), false).FirstOrDefault() as DotNetKoans.KoanAttribute; if (custAttr == null) { continue; } if (queue[custAttr.Position] != null) Console.WriteLine("More than one koan in {0} has the position {1}", className, custAttr.Position); queue[custAttr.Position] = method; if (custAttr.Position > highestKoanNumber) { highestKoanNumber = custAttr.Position; } } int numberOfKoansRunInThisCollection = 0; int numberOfKoansPassedInThisCollection = 0; BindingFlags flags = BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.Public; foreach (MethodInfo test in queue) { if (test == null) continue; ++numberKoansProcessed; numberOfKoansRunInThisCollection++; if (aKoanHasFailed) continue; try { Type attType = typeof(AsyncStateMachineAttribute); // Obtain the custom attribute for the method. // The value returned contains the StateMachineType property. // Null is returned if the attribute isn't present for the method. var attrib = (AsyncStateMachineAttribute)test.GetCustomAttribute(attType); if (attrib != null) { Task t = (classToRun.InvokeMember(test.Name, flags, null, koans, new Object[] { }) as Task); t.Wait(); } else { classToRun.InvokeMember(test.Name, flags, null, koans, new Object[] { }); } } catch (Exception e) { aKoanHasFailed = true; firstFailingKoan = numberKoansProcessed - 1; Exception ie = e.InnerException; if (ie == null) ie = e; string st = ie.StackTrace; string[] stLines = st.Split(new char[] { '\n' }); // uncomment if there are problems parsing the stack trace: /*foreach (string line in stLines) Console.WriteLine(line);*/ string filenameAndLine = ""; foreach (string s in stLines) { filenameAndLine = GetFilenameAndLine(s); if (filenameAndLine != null) break; } // make the message a single line, so that it is completely seen if the Error List pane is selected instead of the Output pane: string message = ie.Message.Replace("\n", " \\ ").Replace("\r", ""); Console.WriteLine("The test {0} has damaged your karma.", test); // Use this format: "file(linenr): warning: " followed by anything, so it shows up as a warning in the Error List pane. // In both the Error List pane and Output pane clicking it jumps to the line where a fix is needed. // Replacing 'warning' by 'error' would work too, but also give a distracting extra error message. Console.WriteLine(filenameAndLine + ": warning: {0}", message); } if (!aKoanHasFailed) numberOfKoansPassedInThisCollection++; } if (numberOfKoansRunInThisCollection != highestKoanNumber) { Console.WriteLine("!!!!WARNING - Some Koans in {0} appear disabled. The highest koan found was {1} but we ran {2} koan(s)", className, highestKoanNumber, numberOfKoansRunInThisCollection); } }
public void NonTestMethodInClassWithTestMethod() { string code = @" using Xunit; public class TestClass { public void NonTestMethod() { } [Fact] public void TestMethod() { } }"; using (MockAssembly assembly = new MockAssembly()) { assembly.Compile(code); XmlNode lastNode = null; using (ExecutorWrapper wrapper = new ExecutorWrapper(assembly.FileName, null, false)) wrapper.RunTest("TestClass", "NonTestMethod", node => { lastNode = node; return true; }); Assert.Equal("class", lastNode.Name); Assert.Equal(0, lastNode.ChildNodes.Count); // Empty class node } }
public void CanCancelBetweenTestMethodRuns() { string code = @" using Xunit; public class TestClass { [Fact] public void TestMethod1() { } [Fact] public void TestMethod2() { } }"; using (MockAssembly assembly = new MockAssembly()) { assembly.Compile(code); XmlNode lastNode = null; using (ExecutorWrapper wrapper = new ExecutorWrapper(assembly.FileName, null, false)) wrapper.RunClass("TestClass", node => { lastNode = node; return false; }); Assert.Equal(0, lastNode.ChildNodes.Count); // Cancels from the start of the first test } }
static int Main(string[] args) { try { Console.WriteLine(""); Console.WriteLine(""); Console.WriteLine("*******************************************************************"); Console.WriteLine("*******************************************************************"); ReadProgress(); string koan_path = args[0]; Xunit.ExecutorWrapper wrapper = new ExecutorWrapper(koan_path, null, false); System.Reflection.Assembly koans = System.Reflection.Assembly.LoadFrom(koan_path); if (koans == null) { Console.WriteLine("Bad Assembly"); return -1; } Type pathType = null; foreach (Type type in koans.GetExportedTypes()) { if (typeof(KoanHelpers.IAmThePathToEnlightenment).IsAssignableFrom(type)) { pathType = type; break; } } KoanHelpers.IAmThePathToEnlightenment path = Activator.CreateInstance(pathType) as KoanHelpers.IAmThePathToEnlightenment; string thePath = path.ThePath; string[] theKoanNames = KoanNames; foreach (string koanName in theKoanNames) { Run(thePath + "." + koanName, koans, wrapper); } Console.WriteLine("{0}", Encouragement()); progress.Add(firstFailingKoan); WriteProgress(); } catch (Exception ex) { Console.WriteLine("Karma has killed the runner. Exception was: " + ex.ToString()); return -1; } if (!aKoanHasFailed) firstFailingKoan = numberKoansProcessed; Console.WriteLine("Koan progress: {0}/{1}", firstFailingKoan, numberKoansProcessed); Console.WriteLine("*******************************************************************"); Console.WriteLine("*******************************************************************"); Console.WriteLine(""); Console.WriteLine(""); return 0; }
public void CallbackIncludesStartMessages() { const string code = @" using Xunit; public class TestClass { [Fact] public void TestMethod1() {} [Fact] public void TestMethod2() {} [Fact] public void TestMethod3() {} }"; using (MockAssembly assembly = new MockAssembly()) { assembly.Compile(code); List<XmlNode> nodes = new List<XmlNode>(); using (ExecutorWrapper wrapper = new ExecutorWrapper(assembly.FileName, null, false)) wrapper.RunTests("TestClass", new List<string> { "TestMethod1" }, node => { nodes.Add(node); return true; }); Assert.Equal(3, nodes.Count); Assert.Equal("start", nodes[0].Name); // <start> ResultXmlUtility.AssertAttribute(nodes[0], "name", "TestClass.TestMethod1"); ResultXmlUtility.AssertAttribute(nodes[0], "type", "TestClass"); ResultXmlUtility.AssertAttribute(nodes[0], "method", "TestMethod1"); Assert.Equal("test", nodes[1].Name); Assert.Equal("class", nodes[2].Name); } }
public XmlNode Run(string configFile) { using (ExecutorWrapper wrapper = new ExecutorWrapper(FileName, configFile, false)) { XmlNode result = null; wrapper.RunAssembly(node => { if (node.Name == "assembly") result = node; return true; }); return result; } }
public void InvalidMethodName() { string code = @" using Xunit; public class TestClass { public void DummyMethod() {} }"; using (MockAssembly assembly = new MockAssembly()) { assembly.Compile(code); using (ExecutorWrapper wrapper = new ExecutorWrapper(assembly.FileName, null, false)) Assert.Throws<ArgumentException>( () => wrapper.RunTests("TestClass", new List<string> { "DummyMethod", "DummyMethod2" }, null)); } }