/// <summary> /// Finds the tests on a test method. /// </summary> /// <param name="testCollection">The test collection that the test method belongs to.</param> /// <param name="type">The test class that the test method belongs to.</param> /// <param name="method">The test method.</param> /// <param name="includeSourceInformation">Set to <c>true</c> to indicate that source information should be included.</param> /// <param name="messageBus">The message bus to report discovery messages to.</param> /// <returns>Return <c>true</c> to continue test discovery, <c>false</c>, otherwise.</returns> protected virtual bool FindTestsForMethod(ITestCollection testCollection, ITypeInfo type, IMethodInfo method, bool includeSourceInformation, IMessageBus messageBus) { var factAttribute = method.GetCustomAttributes(typeof(FactAttribute)).FirstOrDefault(); if (factAttribute == null) return true; var testCaseDiscovererAttribute = factAttribute.GetCustomAttributes(typeof(XunitTestCaseDiscovererAttribute)).FirstOrDefault(); if (testCaseDiscovererAttribute == null) return true; var args = testCaseDiscovererAttribute.GetConstructorArguments().Cast<string>().ToList(); var discovererType = Reflector.GetType(args[1], args[0]); if (discovererType == null) return true; var discoverer = GetDiscoverer(discovererType); if (discoverer == null) return true; foreach (var testCase in discoverer.Discover(testCollection, AssemblyInfo, type, method, factAttribute)) if (!ReportDiscoveredTestCase(testCase, includeSourceInformation, messageBus)) return false; return true; }
public CulturedXunitTestCase(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo type, IMethodInfo method, IAttributeInfo factAttribute, string culture) : base(testCollection, assembly, type, method, factAttribute) { this.culture = culture; Traits.Add("Culture", culture); }
void Initialize(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo type, IMethodInfo method, IAttributeInfo factAttribute, object[] arguments) { string displayNameBase = factAttribute.GetNamedArgument<string>("DisplayName") ?? type.Name + "." + method.Name; ITypeInfo[] resolvedTypes = null; if (arguments != null && method.IsGenericMethodDefinition) { resolvedTypes = ResolveGenericTypes(method, arguments); method = method.MakeGenericMethod(resolvedTypes); } Assembly = assembly; Class = type; Method = method; Arguments = arguments; DisplayName = GetDisplayNameWithArguments(displayNameBase, arguments, resolvedTypes); SkipReason = factAttribute.GetNamedArgument<string>("Skip"); Traits = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase); TestCollection = testCollection; foreach (var traitAttribute in Method.GetCustomAttributes(typeof(ITraitAttribute)) .Concat(Class.GetCustomAttributes(typeof(ITraitAttribute)))) { var discovererAttribute = traitAttribute.GetCustomAttributes(typeof(TraitDiscovererAttribute)).First(); var discoverer = ExtensibilityPointFactory.GetTraitDiscoverer(discovererAttribute); if (discoverer != null) foreach (var keyValuePair in discoverer.GetTraits(traitAttribute)) Traits.Add(keyValuePair.Key, keyValuePair.Value); } uniqueID = new Lazy<string>(GetUniqueID, true); }
void Initialize(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo type, IMethodInfo method, IAttributeInfo factAttribute, object[] arguments) { string displayNameBase = factAttribute.GetNamedArgument<string>("DisplayName") ?? type.Name + "." + method.Name; ITypeInfo[] resolvedTypes = null; if (arguments != null && method.IsGenericMethodDefinition) { resolvedTypes = ResolveGenericTypes(method, arguments); method = method.MakeGenericMethod(resolvedTypes); } Assembly = assembly; Class = type; Method = method; Arguments = arguments; DisplayName = GetDisplayNameWithArguments(displayNameBase, arguments, resolvedTypes); SkipReason = factAttribute.GetNamedArgument<string>("Skip"); Traits = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase); TestCollection = testCollection; foreach (IAttributeInfo traitAttribute in Method.GetCustomAttributes(typeof(TraitAttribute)) .Concat(Class.GetCustomAttributes(typeof(TraitAttribute)))) { var ctorArgs = traitAttribute.GetConstructorArguments().ToList(); Traits.Add((string)ctorArgs[0], (string)ctorArgs[1]); } uniqueID = new Lazy<string>(GetUniqueID, true); }
protected override Task<RunSummary> RunTestCollectionAsync(IMessageBus messageBus, ITestCollection testCollection, IEnumerable<IXunitTestCase> testCases, CancellationTokenSource cancellationTokenSource) { return new XunitTestCollectionRunnerWithAssemblyFixture(assemblyFixtureMappings, testCollection, testCases, DiagnosticMessageSink, messageBus, TestCaseOrderer, new ExceptionAggregator(Aggregator), cancellationTokenSource).RunAsync(); }
/// <summary> /// Initializes a new instance of the <see cref="TestCollectionFinished"/> class. /// </summary> public TestCollectionFinished(IEnumerable<ITestCase> testCases, ITestCollection testCollection, decimal executionTime, int testsRun, int testsFailed, int testsSkipped) : base(testCases, testCollection) { ExecutionTime = executionTime; TestsRun = testsRun; TestsFailed = testsFailed; TestsSkipped = testsSkipped; }
public TestClassFinished(ITestCollection testCollection, string className, decimal executionTime, int testsRun, int testsFailed, int testsSkipped) : base(testCollection, className) { ExecutionTime = executionTime; TestsRun = testsRun; TestsFailed = testsFailed; TestsSkipped = testsSkipped; }
public virtual string DisplayName(ITestCollection testCollection) { var id = assemblyMappings.GetOrAdd( testCollection.TestAssembly.Assembly.Name, key => Interlocked.Increment(ref assemblyCount)); return String.Concat(testCollection.DisplayName, " (", id, ")"); }
/// <summary> /// Initializes a new instance of the <see cref="TestClassCleanupFailure"/> class. /// </summary> public TestCollectionCleanupFailure(IEnumerable<ITestCase> testCases, ITestCollection testCollection, string[] exceptionTypes, string[] messages, string[] stackTraces, int[] exceptionParentIndices) : base(testCases, testCollection) { StackTraces = stackTraces; Messages = messages; ExceptionTypes = exceptionTypes; ExceptionParentIndices = exceptionParentIndices; }
/// <summary> /// Initializes a new instance of the <see cref="TestClass"/> class. /// </summary> /// <param name="testCollection">The test collection the class belongs to</param> /// <param name="class">The test class</param> public TestClass(ITestCollection testCollection, ITypeInfo @class) { Guard.ArgumentNotNull("testCollection", testCollection); Guard.ArgumentNotNull("class", @class); Class = @class; TestCollection = testCollection; }
/// <inheritdoc/> public void SetData(XunitSerializationInfo info) { TestCollection = info.GetValue<ITestCollection>("TestCollection"); var assemblyName = info.GetString("ClassAssemblyName"); var typeName = info.GetString("ClassTypeName"); Class = Reflector.Wrap(Reflector.GetType(assemblyName, typeName)); }
/// <inheritdoc/> protected TestClass(SerializationInfo info, StreamingContext context) { TestCollection = info.GetValue<ITestCollection>("TestCollection"); var assemblyName = info.GetString("ClassAssemblyName"); var typeName = info.GetString("ClassTypeName"); Class = Reflector.Wrap(Reflector.GetType(assemblyName, typeName)); }
/// <inheritdoc/> public void Deserialize(IXunitSerializationInfo info) { TestCollection = info.GetValue<ITestCollection>("TestCollection"); var assemblyName = info.GetValue<string>("ClassAssemblyName"); var typeName = info.GetValue<string>("ClassTypeName"); Class = Reflector.Wrap(SerializationHelper.GetType(assemblyName, typeName)); }
/// <summary> /// Initializes a new instance of the <see cref="XunitTestCase"/> class. /// </summary> /// <param name="testCollection">The test collection this test case belongs to.</param> /// <param name="assembly">The test assembly.</param> /// <param name="type">The test class.</param> /// <param name="method">The test method.</param> /// <param name="factAttribute">The instance of the <see cref="FactAttribute"/>.</param> /// <param name="arguments">The arguments for the test method.</param> public XunitTestCase(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo type, IMethodInfo method, IAttributeInfo factAttribute, object[] arguments = null) { Initialize(testCollection, assembly, type, method, factAttribute, arguments); }
/// <summary> /// Initializes a new instance of the <see cref="Xunit1"/> class. /// </summary> /// <param name="sourceInformationProvider">Source code information provider.</param> /// <param name="assemblyFileName">The test assembly.</param> /// <param name="configFileName">The test assembly configuration file.</param> /// <param name="shadowCopy">If set to <c>true</c>, runs tests in a shadow copied app domain, which allows /// tests to be discovered and run without locking assembly files on disk.</param> public Xunit1(ISourceInformationProvider sourceInformationProvider, string assemblyFileName, string configFileName = null, bool shadowCopy = true) { this.sourceInformationProvider = sourceInformationProvider; this.assemblyFileName = assemblyFileName; this.configFileName = configFileName; executor = CreateExecutor(assemblyFileName, configFileName, shadowCopy); testCollection = new Xunit1TestCollection(assemblyFileName); }
/// <summary> /// Initializes a new instance of the <see cref="TestClassCleanupFailure"/> class. /// </summary> public TestCollectionCleanupFailure(IEnumerable<ITestCase> testCases, ITestCollection testCollection, Exception ex) : base(testCases, testCollection) { var failureInfo = ExceptionUtility.ConvertExceptionToFailureInformation(ex); ExceptionTypes = failureInfo.ExceptionTypes; Messages = failureInfo.Messages; StackTraces = failureInfo.StackTraces; ExceptionParentIndices = failureInfo.ExceptionParentIndices; }
public IEnumerable<IXunitTestCase> Discover(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo testClass, IMethodInfo testMethod, IAttributeInfo factAttribute) { var ctorArgs = factAttribute.GetConstructorArguments().ToArray(); var cultures = Reflector.ConvertArguments(ctorArgs, new[] { typeof(string[]) }).Cast<string[]>().Single(); if (cultures == null || cultures.Length == 0) cultures = new[] { "en-US", "fr-FR" }; return cultures.Select(culture => new CulturedXunitTestCase(testCollection, assembly, testClass, testMethod, factAttribute, culture)).ToList(); }
protected override Task<RunSummary> RunTestCollectionAsync (IMessageBus messageBus, ITestCollection testCollection, IEnumerable<IXunitTestCase> testCases, CancellationTokenSource cancellationTokenSource) { var vsixCollection = testCollection as VsixTestCollection; if (vsixCollection != null) { var runner = new VsixTestCollectionRunner (vsixCollection, testCases, DiagnosticMessageSink, messageBus, TestCaseOrderer, new ExceptionAggregator (Aggregator), cancellationTokenSource); disposables.Add (runner); return runner.RunAsync (); } return new XunitTestCollectionRunner (testCollection, testCases, DiagnosticMessageSink, messageBus, TestCaseOrderer, new ExceptionAggregator (Aggregator), cancellationTokenSource).RunAsync(); }
public TestCollectionRunner(Dictionary<Type, object> assemblyFixtureMappings, ITestCollection testCollection, IEnumerable<IXunitTestCase> testCases, IMessageSink diagnosticMessageSink, IMessageBus messageBus, ITestCaseOrderer testCaseOrderer, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource) : base(testCollection, testCases, diagnosticMessageSink, messageBus, testCaseOrderer, aggregator, cancellationTokenSource) { this.assemblyFixtureMappings = assemblyFixtureMappings; this.diagnosticMessageSink = diagnosticMessageSink; }
public virtual string DisplayName(ITestCollection testCollection) { int id; lock (assemblyMappings) { if (!assemblyMappings.TryGetValue(testCollection.TestAssembly.Assembly.Name, out id)) { id = Interlocked.Increment(ref assemblyCount); assemblyMappings[testCollection.TestAssembly.Assembly.Name] = id; } } return $"{testCollection.DisplayName} ({id})"; }
/// <inheritdoc/> public IEnumerable<XunitTestCase> Discover(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo testClass, IMethodInfo testMethod, IAttributeInfo factAttribute) { // Special case Skip, because we want a single Skip (not one per data item), and a skipped test may // not actually have any data (which is quasi-legal, since it's skipped). if (factAttribute.GetNamedArgument<string>("Skip") != null) return new[] { new XunitTestCase(testCollection, assembly, testClass, testMethod, factAttribute) }; try { using (var memoryStream = new MemoryStream()) { List<XunitTestCase> results = new List<XunitTestCase>(); var dataAttributes = testMethod.GetCustomAttributes(typeof(DataAttribute)); foreach (var dataAttribute in dataAttributes) { var discovererAttribute = dataAttribute.GetCustomAttributes(typeof(DataDiscovererAttribute)).First(); var args = discovererAttribute.GetConstructorArguments().Cast<string>().ToList(); var discovererType = Reflector.GetType(args[1], args[0]); IDataDiscoverer discoverer = (IDataDiscoverer)Activator.CreateInstance(discovererType); // GetData may return null, but that's okay; we'll let the NullRef happen and then catch it // down below so that we get the composite test case. foreach (object[] dataRow in discoverer.GetData(dataAttribute, testMethod)) { // Attempt to serialize the test case, since we need a way to uniquely identify a test // and serialization is the best way to do that. If it's not serializable, this will // throw and we will fall back to a single theory test case that gets its data // at runtime. var testCase = new XunitTestCase(testCollection, assembly, testClass, testMethod, factAttribute, dataRow); SerializationHelper.Serialize(testCase); results.Add(testCase); } } // REVIEW: Could we re-write LambdaTestCase to just be for exceptions? if (results.Count == 0) results.Add(new LambdaTestCase(testCollection, assembly, testClass, testMethod, factAttribute, () => { throw new InvalidOperationException("No data found for " + testClass.Name + "." + testMethod.Name); })); return results; } } catch { return new XunitTestCase[] { new XunitTheoryTestCase(testCollection, assembly, testClass, testMethod, factAttribute) }; } }
Xunit1RunSummary RunTestCollection(ITestCollection testCollection, IEnumerable <ITestCase> testCases, IMessageSink messageSink) { var results = new Xunit1RunSummary(); results.Continue = messageSink.OnMessage(new TestCollectionStarting(testCases, testCollection)); if (results.Continue) { foreach (var testClassGroup in testCases.GroupBy(tc => tc.TestMethod.TestClass, Comparer.Instance)) { var classResults = RunTestClass(testClassGroup.Key, testClassGroup.ToList(), messageSink); results.Aggregate(classResults); if (!classResults.Continue) { break; } } } results.Continue = messageSink.OnMessage(new TestCollectionFinished(testCases, testCollection, results.Time, results.Total, results.Failed, results.Skipped)) && results.Continue; return(results); }
protected override async Task<RunSummary> RunTestCollectionAsync(IMessageBus messageBus, ITestCollection testCollection, IEnumerable<IXunitTestCase> testCases, CancellationTokenSource cancellationTokenSource) { var summary = new RunSummary(); var defaultCases = new List<IXunitTestCase>(); var observationTestCases = new List<ObservationTestCase>(); foreach (var testCase in testCases) { if (testCase is ObservationTestCase) observationTestCases.Add(testCase as ObservationTestCase); else defaultCases.Add(testCase); } if (observationTestCases.Any()) { summary.Aggregate( await new ObservationTestCollectionRunner( testCollection, observationTestCases, DiagnosticMessageSink, messageBus, TestCaseOrderer, new ExceptionAggregator(Aggregator), cancellationTokenSource ) .RunAsync() ); } if (defaultCases.Any()) { summary.Aggregate( await base.RunTestCollectionAsync(messageBus, testCollection, defaultCases, cancellationTokenSource) ); } return summary; }
private ClusterBase ClusterFixture(ITestCollection testCollection) { var clusterType = GetClusterForCollection(testCollection); ClusterBase cluster = null; if (clusterType == null) { return(null); } if (_assemblyFixtureMappings.ContainsKey(clusterType)) { return(_assemblyFixtureMappings[clusterType] as ClusterBase); } Aggregator.Run(() => { var o = Activator.CreateInstance(clusterType); _assemblyFixtureMappings.Add(clusterType, o); cluster = o as ClusterBase; }); return(cluster); }
/// <summary> /// Test collections are not bound to a specific class, however they /// are named by default with the type name as a suffix. We try to /// get the class name from the DisplayName and then use reflection to /// find the class and OrderAttribute. /// </summary> private static int GetOrder( ITestCollection testCollection) { var i = testCollection.DisplayName.LastIndexOf(' '); if (i <= -1) { return(0); } var className = testCollection.DisplayName.Substring(i + 1); var type = Type.GetType(className); if (type == null) { return(0); } var attr = type.GetCustomAttribute <OrderAttribute>(); return(attr?.I ?? 0); }
public virtual void PolymorphicCollectionAddMutlipleItemsOfOneType(string roleObjectType) { var payment = FindById <PolymorphicPayment>(4); var inv = FindById <InvoiceAsPayableItem>(1); string invId = inv.GetPropertyByName("Id").Title; ITestObject inv2 = GetTestService("Invoice As Payable Items").GetAction("New Instance").InvokeReturnObject().Save(); string inv2Id = inv2.GetPropertyByName("Id").Title; ITestCollection links = payment.GetPropertyByName("Payable Item Links").ContentAsCollection; ITestCollection items = payment.GetPropertyByName("Payable Items").ContentAsCollection; links.AssertCountIs(0); items.AssertCountIs(0); //Add an Invoice payment.GetAction("Add Payable Item").InvokeReturnObject(inv); links.AssertCountIs(1); ITestObject link1 = links.ElementAt(0); link1.GetPropertyByName("Associated Role Object Type").AssertValueIsEqual(roleObjectType); link1.GetPropertyByName("Associated Role Object Id").AssertValueIsEqual(invId); items = payment.GetPropertyByName("Payable Items").ContentAsCollection; ITestObject item = items.AssertCountIs(1).ElementAt(0); item.AssertIsType(typeof(InvoiceAsPayableItem)); //Add an expense claim payment.GetAction("Add Payable Item").InvokeReturnObject(inv2); links.AssertCountIs(2); ITestObject link2 = links.ElementAt(1); link2.GetPropertyByName("Associated Role Object Type").AssertValueIsEqual(roleObjectType); link2.GetPropertyByName("Associated Role Object Id").AssertValueIsEqual(inv2Id); items = payment.GetPropertyByName("Payable Items").ContentAsCollection; item = items.AssertCountIs(2).ElementAt(1); item.AssertIsType(typeof(InvoiceAsPayableItem)); }
public virtual void PolymorphicCollectionAddDifferentItems(string roleType1, string roleType2) { var payment = FindById("Polymorphic Payments", 5); var inv = FindById("Invoice As Payable Items", 1); string invId = inv.GetPropertyByName("Id").Title; ITestObject exp = GetTestService("Expense Claim As Payable Items").GetAction("New Instance").InvokeReturnObject().Save(); string expId = exp.GetPropertyByName("Id").Title; ITestCollection links = payment.GetPropertyByName("Payable Item Links").ContentAsCollection; ITestCollection items = payment.GetPropertyByName("Payable Items").ContentAsCollection; links.AssertCountIs(0); items.AssertCountIs(0); //Add an Invoice payment.GetAction("Add Payable Item").InvokeReturnObject(inv); links.AssertCountIs(1); ITestObject link1 = links.ElementAt(0); link1.GetPropertyByName("Associated Role Object Type").AssertValueIsEqual(roleType1); link1.GetPropertyByName("Associated Role Object Id").AssertValueIsEqual(invId); items = payment.GetPropertyByName("Payable Items").ContentAsCollection; ITestObject item = items.AssertCountIs(1).ElementAt(0); item.AssertIsType(typeof(InvoiceAsPayableItem)); //Add an expense claim payment.GetAction("Add Payable Item").InvokeReturnObject(exp); links.AssertCountIs(2); ITestObject link2 = links.ElementAt(1); link2.GetPropertyByName("Associated Role Object Type").AssertValueIsEqual(roleType2); link2.GetPropertyByName("Associated Role Object Id").AssertValueIsEqual(expId); items = payment.GetPropertyByName("Payable Items").ContentAsCollection; item = items.AssertCountIs(2).ElementAt(1); item.AssertIsType(typeof(ExpenseClaimAsPayableItem)); }
private int FindExecutionOrder(ITestCollection collection) { int?order = null; for (int i = 0; i < _orderedCollections.Length; i++) { if (_orderedCollections[i] == collection.DisplayName) { order = i; break; } } if (order is null) { throw new ArgumentException( $"Collection \"{collection.DisplayName}\" not found in execution list.", nameof(collection) ); } return((int)order); }
void Initialize(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo type, IMethodInfo method, IAttributeInfo factAttribute, object[] arguments) { string displayNameBase = factAttribute.GetNamedArgument <string>("DisplayName") ?? type.Name + "." + method.Name; ITypeInfo[] resolvedTypes = null; if (arguments != null && method.IsGenericMethodDefinition) { resolvedTypes = ResolveGenericTypes(method, arguments); method = method.MakeGenericMethod(resolvedTypes); } Assembly = assembly; Class = type; Method = method; Arguments = arguments; DisplayName = GetDisplayNameWithArguments(displayNameBase, arguments, resolvedTypes); SkipReason = factAttribute.GetNamedArgument <string>("Skip"); Traits = new Dictionary <string, List <string> >(StringComparer.OrdinalIgnoreCase); TestCollection = testCollection; foreach (var traitAttribute in Method.GetCustomAttributes(typeof(ITraitAttribute)) .Concat(Class.GetCustomAttributes(typeof(ITraitAttribute)))) { var discovererAttribute = traitAttribute.GetCustomAttributes(typeof(TraitDiscovererAttribute)).First(); var discoverer = ExtensibilityPointFactory.GetTraitDiscoverer(discovererAttribute); if (discoverer != null) { foreach (var keyValuePair in discoverer.GetTraits(traitAttribute)) { Traits.Add(keyValuePair.Key, keyValuePair.Value); } } } uniqueID = new Lazy <string>(GetUniqueID, true); }
public virtual void AttemptToAddSameItemTwice() { var payment = FindById("Polymorphic Payments", 6); var inv = FindById("Invoice As Payable Items", 1); string invId = inv.GetPropertyByName("Id").Title; ITestCollection links = payment.GetPropertyByName("Payable Item Links").ContentAsCollection; ITestCollection items = payment.GetPropertyByName("Payable Items").ContentAsCollection; links.AssertCountIs(0); items.AssertCountIs(0); //Add an Invoice payment.GetAction("Add Payable Item").InvokeReturnObject(inv); links.AssertCountIs(1); items = payment.GetPropertyByName("Payable Items").ContentAsCollection; items.AssertCountIs(1); //Try adding same expense claim again payment.GetAction("Add Payable Item").InvokeReturnObject(inv); links.AssertCountIs(1); //Should still be 1 items = payment.GetPropertyByName("Payable Items").ContentAsCollection; items.AssertCountIs(1); }
public virtual void RemoveItem() { var payment = FindById("Polymorphic Payments", 7); var inv = FindById("Invoice As Payable Items", 1); string invId = inv.GetPropertyByName("Id").Title; ITestCollection links = payment.GetPropertyByName("Payable Item Links").ContentAsCollection; ITestCollection items = payment.GetPropertyByName("Payable Items").ContentAsCollection; links.AssertCountIs(0); items.AssertCountIs(0); //Add an Invoice payment.GetAction("Add Payable Item").InvokeReturnObject(inv); links.AssertCountIs(1); items = payment.GetPropertyByName("Payable Items").ContentAsCollection; ITestCollection item = items.AssertCountIs(1); //Now remove the invoice payment.GetAction("Remove Payable Item").InvokeReturnObject(inv); links.AssertCountIs(0); items = payment.GetPropertyByName("Payable Items").ContentAsCollection; items.AssertCountIs(0); }
protected override async Task <RunSummary> RunTestCollectionAsync( IMessageBus messageBus, ITestCollection testCollection, IEnumerable <IXunitTestCase> testCases, CancellationTokenSource cancellationTokenSource) { var runner = new XunitTestCollectionRunnerWithAssemblyFixture( _assemblyFixtureMappings, testCollection, testCases, DiagnosticMessageSink, messageBus, TestCaseOrderer, new ExceptionAggregator(Aggregator), cancellationTokenSource ); var summary = await runner.RunAsync(); var fixture = (TestsFixture)_assemblyFixtureMappings.Single().Value; fixture.RunSummary.Aggregate(summary); return(summary); }
protected override Task <RunSummary> RunTestCollectionAsync(IMessageBus bus, ITestCollection col, IEnumerable <IXunitTestCase> testCases, CancellationTokenSource cts) => new TestCollectionRunner( assemblyFixtureMappings, col, testCases, DiagnosticMessageSink, bus, TestCaseOrderer, new ExceptionAggregator(Aggregator), cts ).RunAsync();
/// <summary> /// Initializes a new instance of the <see cref="LambdaTestCase"/> class. /// </summary> /// <param name="testCollection">The test collection this test case belongs to.</param> /// <param name="assembly">The test assembly.</param> /// <param name="testClass">The test class.</param> /// <param name="testMethod">The test method.</param> /// <param name="factAttribute">The instance of <see cref="FactAttribute"/>.</param> /// <param name="lambda">The code to run for the test.</param> public LambdaTestCase(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo testClass, IMethodInfo testMethod, IAttributeInfo factAttribute, Action lambda) : base(testCollection, assembly, testClass, testMethod, factAttribute) { this.lambda = lambda; }
protected override Task <RunSummary> RunTestCollectionAsync(IMessageBus messageBus, ITestCollection testCollection, IEnumerable <IXunitTestCase> testCases, CancellationTokenSource cancellationTokenSource) { Task <RunSummary> result = null; ExecutionContext.Run(_context, state => result = new CollectionRunner(_assemblyFixtureMappings, testCollection, testCases, DiagnosticMessageSink, messageBus, TestCaseOrderer, new ExceptionAggregator(Aggregator), cancellationTokenSource).RunAsync(), state: null); return(result); }
XElement GetTestCollectionElement(ITestCollection testCollection) { return(_testCollectionElements.GetOrAdd(testCollection, tc => new XElement("collection"))); }
/// <summary> /// Initializes a new instance of the <see cref="TestCollectionMessage"/> class. /// </summary> internal TestCollectionMessage(ITestCase testCase, ITestCollection testCollection) : base(testCase, testCollection.TestAssembly) { TestCollection = testCollection; }
/// <summary> /// Override this method to run the tests in an individual test collection. /// </summary> /// <param name="messageBus">The message bus to report run status to.</param> /// <param name="testCollection">The test collection that is being run.</param> /// <param name="testCases">The test cases to be run.</param> /// <param name="cancellationTokenSource">The task cancellation token source, used to cancel the test run.</param> /// <returns>Returns summary information about the tests that were run.</returns> protected abstract Task <RunSummary> RunTestCollectionAsync(IMessageBus messageBus, ITestCollection testCollection, IEnumerable <TTestCase> testCases, CancellationTokenSource cancellationTokenSource);
/// <summary> /// Initializes a new instance of the <see cref="XunitTestClass"/> class. /// </summary> public XunitTestClass(ITestCollection testCollection, ITypeInfo @class) { Class = @class; TestCollection = testCollection; }
void LogTestCollectionDetails(ITestCollection collection, Action <string> log = null, StringBuilder sb = null) { do_log($" Test collection: {collection.DisplayName}", log, sb); }
protected override Task <RunSummary> RunTestCollectionAsync(IMessageBus messageBus, ITestCollection testCollection, IEnumerable <IXunitTestCase> testCases, CancellationTokenSource cancellationTokenSource) => new XunitInjectingTestCollectionRunner(testCollection, testCases, DiagnosticMessageSink, messageBus, TestCaseOrderer, new ExceptionAggregator(Aggregator), cancellationTokenSource).RunAsync();
public TestMethodStarting(ITestCollection testCollection, string className, string methodName) : base(testCollection) { ClassName = className; MethodName = methodName; }
protected override Task <RunSummary> RunTestCollectionAsync(IMessageBus messageBus, ITestCollection testCollection, IEnumerable <ITestCase> testCases, CancellationTokenSource cancellationTokenSource) { if (cancelInRunTestCollectionAsync) { cancellationTokenSource.Cancel(); } RunTestCollectionAsync_AggregatorResult = Aggregator.ToException(); CollectionsRun.Add(Tuple.Create(testCollection, testCases)); return(Task.FromResult(result)); }
/// <summary> /// Initializes a new instance of the <see cref="TestCollectionMessage"/> class. /// </summary> public TestCollectionMessage(IEnumerable<ITestCase> testCases, ITestCollection testCollection) : base(testCases, testCollection.TestAssembly) { TestCollection = testCollection; }
protected override Task <RunSummary> RunTestCollectionAsync(IMessageBus messageBus, ITestCollection testCollection, IEnumerable <IXunitTestCase> testCases, CancellationTokenSource cancellationTokenSource) { return(new CollectionRunner(testCollection, testCases, DiagnosticMessageSink, messageBus, TestCaseOrderer, new ExceptionAggregator(Aggregator), cancellationTokenSource, _assemblyFixtureMappings).RunAsync()); }
public TestMethodFinished(ITestCollection testCollection, string className, string methodName) : base(testCollection) { ClassName = className; MethodName = methodName; }
RunSummary RunTestClass(ITestCollection testCollection, string className, IList<Xunit1TestCase> testCases, IMessageSink messageSink) { var handler = new TestClassCallbackHandler(testCases, messageSink); var results = handler.TestClassResults; results.Continue = messageSink.OnMessage(new TestClassStarting(testCollection, className)); if (results.Continue) { try { var methodNames = testCases.Select(tc => tc.Method.Name).ToList(); executor.RunTests(className, methodNames, handler); handler.LastNodeArrived.WaitOne(); } catch (Exception ex) { var stackTrace = ex.StackTrace; var rethrowIndex = stackTrace.IndexOf("$$RethrowMarker$$"); if (rethrowIndex > -1) stackTrace = stackTrace.Substring(0, rethrowIndex); results.Continue = messageSink.OnMessage(new ErrorMessage(ex.GetType().FullName, ex.Message, stackTrace)) && results.Continue; } } results.Continue = messageSink.OnMessage(new TestClassFinished(testCollection, className, results.Time, results.Total, results.Failed, results.Skipped)) && results.Continue; return results; }
public CollectionRunner(Dictionary <Type, object> assemblyFixtureMappings, ITestCollection testCollection, IEnumerable <IXunitTestCase> testCases, IMessageSink diagnosticMessageSink, IMessageBus messageBus, ITestCaseOrderer testCaseOrderer, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource) : base(testCollection, testCases, diagnosticMessageSink, messageBus, testCaseOrderer, aggregator, cancellationTokenSource) { _assemblyFixtureMappings = assemblyFixtureMappings; }
public TestCollectionMessage(ITestCollection testCollection) { TestCollection = testCollection; }
XElement GetTestCollectionElement(ITestCollection testCollection) { lock (testCollectionElements) return(testCollectionElements.GetOrAdd(testCollection.UniqueID, () => new XElement("collection"))); }
public static XunitTheoryTestCase XunitTheoryTestCase <TClassUnderTest>(string methodName, ITestCollection collection = null, IMessageSink diagnosticMessageSink = null) { var method = TestMethod(typeof(TClassUnderTest), methodName, collection); return(new XunitTheoryTestCase(diagnosticMessageSink ?? new Xunit.NullMessageSink(), TestMethodDisplay.ClassAndMethod, method)); }
public TestFrameworkCollectionRunner(ITestCollection testCollection, IEnumerable <IXunitTestCase> testCases, IMessageSink diagnosticMessageSink, IMessageBus messageBus, ITestCaseOrderer testCaseOrderer, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource) : base(testCollection, testCases, diagnosticMessageSink, messageBus, testCaseOrderer, aggregator, cancellationTokenSource) { _diagnosticMessageSink = diagnosticMessageSink; }
/// <inheritdoc/> public IEnumerable <IXunitTestCase> Discover(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo testClass, IMethodInfo testMethod, IAttributeInfo factAttribute) { yield return(new XunitTestCase(testCollection, assembly, testClass, testMethod, factAttribute)); }
RunSummary RunTestClass(ITestCollection testCollection, string className, IList<Xunit1TestCase> testCases, IMessageSink messageSink) { var handler = new TestClassCallbackHandler(testCases, messageSink); var results = handler.TestClassResults; results.Continue = messageSink.OnMessage(new TestClassStarting(testCollection, className)); if (results.Continue) { try { var methodNames = testCases.Select(tc => tc.Method.Name).ToList(); executor.RunTests(className, methodNames, handler); handler.LastNodeArrived.WaitOne(); } catch (Exception ex) { var failureInformation = Xunit1ExceptionUtility.ConvertToFailureInformation(ex); results.Continue = messageSink.OnMessage(new ErrorMessage(failureInformation.ExceptionTypes, failureInformation.Messages, failureInformation.StackTraces, failureInformation.ExceptionParentIndices)) && results.Continue; } } results.Continue = messageSink.OnMessage(new TestClassFinished(testCollection, className, results.Time, results.Total, results.Failed, results.Skipped)) && results.Continue; return results; }
/// <summary> /// Initializes a new instance of the <see cref="XunitTheoryTestCase"/> class. /// </summary> /// <param name="testCollection">The test collection this theory belongs to.</param> /// <param name="assembly">The test assembly.</param> /// <param name="type">The type under test.</param> /// <param name="method">The method under test.</param> /// <param name="theoryAttribute">The theory attribute.</param> public XunitTheoryTestCase(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo type, IMethodInfo method, IAttributeInfo theoryAttribute) : base(testCollection, assembly, type, method, theoryAttribute) { }
RunSummary RunTestCollection(ITestCollection testCollection, IEnumerable<Xunit1TestCase> testCases, IMessageSink messageSink) { var results = new RunSummary(); results.Continue = messageSink.OnMessage(new TestCollectionStarting(testCollection)); if (results.Continue) foreach (var testClassGroup in testCases.GroupBy(tc => tc.Class.Name)) { var classResults = RunTestClass(testCollection, testClassGroup.Key, testClassGroup.ToList(), messageSink); results.Aggregate(classResults); if (!classResults.Continue) break; } results.Continue = messageSink.OnMessage(new TestCollectionFinished(testCollection, results.Time, results.Total, results.Failed, results.Skipped)) && results.Continue; return results; }
public TestClassStarting(ITestCollection testCollection, string className) : base(testCollection) { ClassName = className; }
protected override Task <RunSummary> RunTestCollectionAsync(IMessageBus messageBus, ITestCollection testCollection, IEnumerable <IXunitTestCase> testCases, CancellationTokenSource cancellationTokenSource) { TestCasesRun.Add(Tuple.Create(Thread.CurrentThread.ManagedThreadId, testCases)); Thread.Sleep(5); // Hold onto the worker thread long enough to ensure tests all get spread around return(Task.FromResult(new RunSummary())); }
protected override Task <RunSummary> RunTestCollectionAsync(IMessageBus messageBus, ITestCollection testCollection, IEnumerable <IXunitTestCase> testCases, CancellationTokenSource cancellationTokenSource) { var collectionRunner = new XunitTestCollectionRunner(messageBus, testCollection, testCases, TestCaseOrderer, cancellationTokenSource); return(collectionRunner.RunAsync()); }