/// <summary> /// A container type that handles an entire test class throughout the /// test run. /// </summary> /// <param name="filter">Test run filter object.</param> /// <param name="testHarness">The unit test harness.</param> /// <param name="testClass">The test class metadata interface.</param> /// <param name="instance">The object instance.</param> /// <param name="provider">The unit test provider.</param> public TestClassManager(TestRunFilter filter, UnitTestHarness testHarness, ITestClass testClass, object instance, IUnitTestProvider provider) : base(testHarness, provider) { _filter = filter; _testClass = testClass; _testExecutionQueue = new CompositeWorkItem(); _instance = instance; }
public override List<ITestMethod> GetTestMethods(ITestClass test, object instance) { return new List<ITestMethod> { _method }; }
/// <summary> /// Constructor for a test method manager, which handles executing a single test method /// for a unit test provider. /// </summary> /// <param name="testHarness">The unit test harness object.</param> /// <param name="testClass">The test class metadata object.</param> /// <param name="testMethod">The test method metadata object.</param> /// <param name="instance">The test class instance.</param> /// <param name="provider">The unit test provider.</param> public TestMethodManager(UnitTestHarness testHarness, ITestClass testClass, ITestMethod testMethod, object instance, IUnitTestProvider provider) : base(testHarness, provider) { _testClass = testClass; _testMethod = testMethod; _instance = instance; }
/// <summary> /// Initializes a new test run filter using an existing settings file. /// </summary> /// <param name="test">The test class metadata.</param> /// <param name="method">The test method metadata.</param> public RetryTestRunFilter(ITestClass test, ITestMethod method) : base(null, null) { TestRunName = "Retry of " + test.Name + " " + method.Name; _test = test; _method = method; }
/// <summary> /// Creates a result record. /// </summary> /// <param name="method">Test method metadata object.</param> /// <param name="testClass">Test class metadata object.</param> /// <param name="result">Test result object.</param> /// <param name="exception">Exception instance, if any.</param> public ScenarioResult(ITestMethod method, ITestClass testClass, TestOutcome result, Exception exception) { TestClass = testClass; TestMethod = method; Exception = exception; Result = result; }
/// <summary> /// Initializes a new instance of the TestClassData type. /// </summary> /// <param name="testClass">The test class metadata.</param> /// <param name="parent">The parent test assembly data object.</param> public TestClassData(ITestClass testClass, TestAssemblyData parent) { _methods = new ObservableCollection<TestMethodData>(); _parent = parent; Name = testClass.Name; Namespace = testClass.Namespace; }
/// <summary> /// Initializes a new instance of the <see cref="TestMethod"/> class. /// </summary> /// <param name="class">The test class</param> /// <param name="method">The test method</param> public TestMethod(ITestClass @class, IMethodInfo method) { Guard.ArgumentNotNull("class", @class); Guard.ArgumentNotNull("method", method); Method = method; TestClass = @class; }
/// <inheritdoc/> public void Deserialize(IXunitSerializationInfo info) { TestClass = info.GetValue<ITestClass>("TestClass"); var methodName = info.GetValue<string>("MethodName"); Method = TestClass.Class.GetMethod(methodName, includePrivateMethod: true); }
/// <inheritdoc/> public void SetData(XunitSerializationInfo info) { TestClass = info.GetValue<ITestClass>("TestClass"); var methodName = info.GetString("MethodName"); Method = TestClass.Class.GetMethod(methodName, includePrivateMethod: false); }
/// <summary> /// Initializes a new instance of the <see cref="TestClassCleanupFailure"/> class. /// </summary> public TestClassCleanupFailure(IEnumerable<ITestCase> testCases, ITestClass testClass, string[] exceptionTypes, string[] messages, string[] stackTraces, int[] exceptionParentIndices) : base(testCases, testClass) { StackTraces = stackTraces; Messages = messages; ExceptionTypes = exceptionTypes; ExceptionParentIndices = exceptionParentIndices; }
/// <inheritdoc/> protected TestMethod(SerializationInfo info, StreamingContext context) { TestClass = info.GetValue<ITestClass>("TestClass"); var methodName = info.GetString("MethodName"); Method = TestClass.Class.GetMethod(methodName, includePrivateMethod: false); }
/// <summary> /// Initializes a new instance of the <see cref="TestClassFinished"/> class. /// </summary> public TestClassFinished(IEnumerable<ITestCase> testCases, ITestClass testClass, decimal executionTime, int testsRun, int testsFailed, int testsSkipped) : base(testCases, testClass) { ExecutionTime = executionTime; TestsRun = testsRun; TestsFailed = testsFailed; TestsSkipped = testsSkipped; }
/// <summary> /// Initializes a new instance of the <see cref="TestClassCleanupFailure"/> class. /// </summary> public TestClassCleanupFailure(IEnumerable<ITestCase> testCases, ITestClass testClass, Exception ex) : base(testCases, testClass) { var failureInfo = ExceptionUtility.ConvertExceptionToFailureInformation(ex); ExceptionTypes = failureInfo.ExceptionTypes; Messages = failureInfo.Messages; StackTraces = failureInfo.StackTraces; ExceptionParentIndices = failureInfo.ExceptionParentIndices; }
public TestClassDispatcher( UnitTestHarness testHarness, ITestClass testClass, object instance, IUnitTestProvider provider) : base(testHarness, provider) { _testClass = testClass; _testExecutionQueue = new TestWorkItemDispatcher(); _instance = instance; }
/// <summary> /// Initializes a new failure web control. /// </summary> /// <param name="testClass">The test class metadata object.</param> /// <param name="summaryControl">The overall summary control.</param> public FailureControl(ITestClass testClass, FailureSummaryControl summaryControl) : base() { _summary = summaryControl; Margin.All = 0; Margin.Top = 4; Margin.Bottom = 2; CreateClassHeader(testClass.Name); }
protected override Task<RunSummary> RunTestClassAsync(ITestClass testClass, IReflectionTypeInfo @class, IEnumerable<IXunitTestCase> testCases) { var combinedFixtures = new Dictionary<Type, object>(assemblyFixtureMappings); foreach (var kvp in CollectionFixtureMappings) combinedFixtures[kvp.Key] = kvp.Value; // We've done everything we need, so let the built-in types do the rest of the heavy lifting return new XunitTestClassRunner(testClass, @class, testCases, diagnosticMessageSink, MessageBus, TestCaseOrderer, new ExceptionAggregator(Aggregator), CancellationTokenSource, combinedFixtures).RunAsync(); }
/// <summary> /// Logs and Exception that was intercepted or observed. /// </summary> /// <param name="exception">The actual Exception instance.</param> /// <param name="test">The test class metadata.</param> /// <param name="method">The test method metadata.</param> public void LogException(Exception exception, ITestClass test, ITestMethod method) { string message = String.Format(CultureInfo.CurrentCulture, Properties.UnitTestMessage.LogException, exception.GetType().ToString(), exception.Message); LogMessage m = Create(LogMessageType.Error, message); MarkUnitTestMessage(m); DecorateTestGranularity(m, TestGranularity.TestScenario); m[UnitTestLogDecorator.ActualException] = exception; m[UnitTestLogDecorator.TestClassMetadata] = test; m[UnitTestLogDecorator.TestMethodMetadata] = method; Enqueue(m); }
/// <summary> /// No Exception was intercepted, yet one was expected. /// </summary> /// <param name="expectedExceptionType">The expected exception type.</param> /// <param name="test">The test class metadata.</param> /// <param name="method">The test method metadata.</param> public void NoExceptionWhenExpected(Type expectedExceptionType, ITestClass test, ITestMethod method) { string message = String.Format(CultureInfo.CurrentCulture, Properties.UnitTestMessage.LogNoException, expectedExceptionType.ToString()); LogMessage m = Create(LogMessageType.Error, message); MarkUnitTestMessage(m); DecorateTestGranularity(m, TestGranularity.TestScenario); m[UnitTestLogDecorator.IncorrectExceptionMessage] = true; m[UnitTestLogDecorator.ExpectedExceptionType] = expectedExceptionType; m[UnitTestLogDecorator.TestClassMetadata] = test; m[UnitTestLogDecorator.TestMethodMetadata] = method; Enqueue(m); }
protected override bool FindTestsForType(ITestClass testClass, bool includeSourceInformation, IMessageBus messageBus, ITestFrameworkDiscoveryOptions discoveryOptions) { var methodDisplay = discoveryOptions.MethodDisplayOrDefault(); foreach (var method in testClass.Class.GetMethods(includePrivateMethods: true)) if (!FindTestsForMethod(new TestMethod(testClass, method), methodDisplay, includeSourceInformation, messageBus)) return false; return true; }
public void IncorrectException(Type expectedExceptionType, Type actualExceptionType, ITestClass test, ITestMethod method) { string message = String.Format(System.Globalization.CultureInfo.CurrentCulture, Properties.UnitTestMessage.LogIncorrectExceptionType, actualExceptionType.Name, expectedExceptionType.Name); LogMessage m = Create(LogMessageType.Error, message); MarkUnitTestMessage(m); DecorateTestGranularity(m, TestGranularity.TestScenario); m[UnitTestLogDecorator.IncorrectExceptionMessage] = true; m[UnitTestLogDecorator.ExpectedExceptionType] = expectedExceptionType; m[UnitTestLogDecorator.ActualExceptionType] = actualExceptionType; m[UnitTestLogDecorator.TestClassMetadata] = test; m[UnitTestLogDecorator.TestMethodMetadata] = method; Enqueue(m); }
public VsixTestClassRunner (IVsClient vsClient, ITestClass testClass, IReflectionTypeInfo @class, IEnumerable<IXunitTestCase> testCases, IMessageSink diagnosticMessageSink, IMessageBus messageBus, ITestCaseOrderer testCaseOrderer, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource, IDictionary<Type, object> collectionFixtureMappings) : base (testClass, @class, testCases, diagnosticMessageSink, messageBus, testCaseOrderer, aggregator, cancellationTokenSource, collectionFixtureMappings) { this.vsClient = vsClient; }
protected override Task<RunSummary> RunTestClassAsync(ITestClass testClass, IReflectionTypeInfo @class, IEnumerable<IXunitTestCase> testCases) { foreach (var fixtureType in @class.Type.GetTypeInfo().ImplementedInterfaces .Where(i => i.GetTypeInfo().IsGenericType && i.GetGenericTypeDefinition() == typeof(IAssemblyFixture<>)) .Select(i => i.GetTypeInfo().GenericTypeArguments.Single()) // First pass at filtering out before locking .Where(i => !assemblyFixtureMappings.ContainsKey(i))) { // ConcurrentDictionary's GetOrAdd does not lock around the value factory call, so we need // to do it ourselves. lock (assemblyFixtureMappings) if (!assemblyFixtureMappings.ContainsKey(fixtureType)) Aggregator.Run(() => assemblyFixtureMappings.Add(fixtureType, Activator.CreateInstance(fixtureType))); } // Don't want to use .Concat + .ToDictionary because of the possibility of overriding types, // so instead we'll just let collection fixtures override assembly fixtures. var combinedFixtures = new Dictionary<Type, object>(assemblyFixtureMappings); foreach (var kvp in CollectionFixtureMappings) combinedFixtures[kvp.Key] = kvp.Value; // We've done everything we need, so let the built-in types do the rest of the heavy lifting return new XunitTestClassRunner(testClass, @class, testCases, diagnosticMessageSink, MessageBus, TestCaseOrderer, new ExceptionAggregator(Aggregator), CancellationTokenSource, combinedFixtures).RunAsync(); }
/// <summary> /// Gets or creates the data model object for a test class. /// </summary> /// <param name="testClass">The test class.</param> /// <returns>Returns the data object.</returns> public TestClassData GetClassModel(ITestClass testClass) { TestClassData data; if (!_classData.TryGetValue(testClass, out data)) { TestAssemblyData tad = GetAssemblyModel(testClass.Assembly); data = new TestClassData(testClass, tad); _classData.Add(testClass, data); // Make sure in parent collection tad.TestClasses.Add(data); } return data; }
public virtual bool FindTestsForClass(ITestClass testClass, bool includeSourceInformation = false) { using (var messageBus = new MessageBus(Sink)) return base.FindTestsForType(testClass, includeSourceInformation, messageBus, TestFrameworkOptions.ForDiscovery()); }
/// <summary> /// Initializes a new instance of the TestClassCompletedEventArgs /// class. /// </summary> /// <param name="testClass">Test class metadata.</param> /// <param name="harness">The harness instance.</param> public TestClassCompletedEventArgs(ITestClass testClass, UnitTestHarness harness) : base(harness) { TestClass = testClass; }
/// <summary> /// Initializes a new instance of the TestMethodStartingEventArgs type. /// </summary> /// <param name="testMethod">The test method metadata.</param> /// <param name="testClass">The test class metadata.</param> /// <param name="harness">The test harness instance.</param> public TestMethodStartingEventArgs(ITestMethod testMethod, ITestClass testClass, UnitTestHarness harness) : base(harness) { TestMethod = testMethod; TestClass = testClass; }
/// <summary> /// Initializes a new instance of the <see cref="TestClassMessage"/> class. /// </summary> public TestClassMessage(IEnumerable<ITestCase> testCases, ITestClass testClass) : base(testCases, testClass.TestCollection) { TestClass = testClass; }
protected override Task <RunSummary> RunTestClassAsync(ITestClass testClass, IReflectionTypeInfo @class, IEnumerable <IXunitTestCase> testCases) { return(Task.FromResult(new RunSummary())); }
public static void RegisterClassFixturesAndModules(this ContainerBuilder builder, ITestClass testClass, IReflectionTypeInfo @class) { foreach (var fixtureType in @class.Type.GetTypeParametersFromInterfaces(typeof(IClassFixture <>))) { builder.RegisterModules(fixtureType); builder.RegisterType(fixtureType).AsSelf().SingleInstance(); } if (testClass.TestCollection.CollectionDefinition != null) { var declarationType = ((IReflectionTypeInfo)testClass.TestCollection.CollectionDefinition).Type; foreach (var fixtureType in declarationType.GetTypeParametersFromInterfaces(typeof(IClassFixture <>))) { builder.RegisterModules(fixtureType); builder.RegisterType(fixtureType).AsSelf().SingleInstance(); } } }
public NestedClassWithInterfaces(ITestClass childOne, IMultipleConstructors childTwo) { ChildOne = childOne; ChildTwo = childTwo; }
public HomeController(ITestClass klass) { _klass = klass; }
protected override Task <RunSummary> RunTestClassAsync(ITestClass testClass, IReflectionTypeInfo typeInfo, IEnumerable <IXunitTestCase> testCases) { return(new ClassRunner(testClass, typeInfo, testCases, _diagnosticMessageSink, MessageBus, TestCaseOrderer, new ExceptionAggregator(Aggregator), CancellationTokenSource, CollectionFixtureMappings, _assemblyFixtureMappings).RunAsync()); }
protected override bool FindTestsForType(ITestClass testClass, bool includeSourceInformation, IMessageBus messageBus, ITestFrameworkDiscoveryOptions discoveryOptions) { EnsureArg.IsNotNull(testClass, nameof(testClass)); EnsureArg.IsNotNull(messageBus, nameof(messageBus)); EnsureArg.IsNotNull(discoveryOptions, nameof(discoveryOptions)); var attributeInfo = testClass.Class.GetCustomAttributes(typeof(FixtureArgumentSetsAttribute)).SingleOrDefault(); if (attributeInfo == null) { return(base.FindTestsForType(testClass, includeSourceInformation, messageBus, discoveryOptions)); } // get the class-level parameter sets in the form (Arg1.OptionA, Arg1.OptionB), (Arg2.OptionA, Arg2.OptionB) SingleFlag[][] classLevelOpenParameterSets = ExpandEnumFlagsFromAttributeData(attributeInfo); // convert these to the form (Arg1.OptionA, Arg2.OptionA), (Arg1.OptionA, Arg2.OptionB), (Arg1.OptionB, Arg2.OptionA), (Arg1.OptionB, Arg2.OptionB) SingleFlag[][] classLevelClosedParameterSets = CartesianProduct(classLevelOpenParameterSets).Select(e => e.ToArray()).ToArray(); foreach (var method in testClass.Class.GetMethods(true)) { IAttributeInfo fixtureParameterAttributeInfo = method.GetCustomAttributes(typeof(FixtureArgumentSetsAttribute)).SingleOrDefault(); SingleFlag[][] closedSets = classLevelClosedParameterSets; if (fixtureParameterAttributeInfo != null) { // get the method-level parameter sets in the form (Arg1.OptionA, Arg1.OptionB), (Arg2.OptionA, Arg2.OptionB) SingleFlag[][] methodLevelOpenParameterSets = ExpandEnumFlagsFromAttributeData(fixtureParameterAttributeInfo); bool hasOverride = false; for (int i = 0; i < methodLevelOpenParameterSets.Length; i++) { if (methodLevelOpenParameterSets[i]?.Length > 0) { hasOverride = true; } else { // means take the class-level set methodLevelOpenParameterSets[i] = classLevelOpenParameterSets[i]; } } if (hasOverride) { // convert to the form (Arg1.OptionA, Arg2.OptionA), (Arg1.OptionA, Arg2.OptionB), (Arg1.OptionB, Arg2.OptionA), (Arg1.OptionB, Arg2.OptionB) closedSets = CartesianProduct(methodLevelOpenParameterSets).Select(e => e.ToArray()).ToArray(); } } foreach (SingleFlag[] closedVariant in closedSets) { var closedVariantTestClass = new TestClassWithFixtureArguments(testClass.TestCollection, testClass.Class, closedVariant); var closedVariantTestMethod = new TestMethod(closedVariantTestClass, method); if (!FindTestsForMethod(closedVariantTestMethod, includeSourceInformation, messageBus, discoveryOptions)) { return(false); } } } return(true); }
public GenericTestMethod(ITestClass @class, IMethodInfo method, ITypeInfo genericArgument) { this.Method = method; this.TestClass = @class; this.GenericArgument = genericArgument; }
void LogTestClassDetails(ITestClass klass, Action <string> log = null, StringBuilder sb = null) { do_log($" Class name: {klass.Class.Name}", log, sb); do_log($" Class assembly: {klass.Class.Assembly.Name}", OnDebug, sb); do_log($" Class assembly path: {klass.Class.Assembly.AssemblyPath}", OnDebug, sb); }
/// <summary> /// Initializes a new instance of the TestClassStartingEventArgs type. /// </summary> /// <param name="testClass">The test class metadata.</param> /// <param name="harness">The unit test harness reference.</param> public TestClassStartingEventArgs(ITestClass testClass, UnitTestHarness harness) : base(harness) { TestClass = testClass; }
/// <summary> /// Initializes a new instance of the <see cref="TestClassMessage"/> class. /// </summary> public TestClassMessage(IEnumerable <ITestCase> testCases, ITestClass testClass) : base(testCases, testClass.TestCollection) { TestClass = testClass; }
private bool IsSpecFlowTest(ITestClass testClass) { return(testClass is SpecFlowFeatureTestClass); }
/// <summary> /// Creates a new TestMethodManager. /// </summary> /// <param name="provider">The unit test provider.</param> /// <param name="testClass">The test class metadata.</param> /// <param name="method">The test method metadata.</param> /// <param name="instance">The test class instance.</param> /// <returns>Returns a new TestMethodManager.</returns> public TestMethodManager CreateTestMethodManager(IUnitTestProvider provider, ITestClass testClass, ITestMethod method, object instance) { return(new TestMethodManager(_harness, testClass, method, instance, provider)); }
public ClassRunner(ITestClass testClass, IReflectionTypeInfo typeInfo, IEnumerable <IXunitTestCase> testCases, IMessageSink diagnosticMessageSink, IMessageBus messageBus, ITestCaseOrderer testCaseOrderer, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource, IDictionary <Type, object> collectionFixtureMappings, IReadOnlyDictionary <Type, object> assemblyFixtureMappings, XunitTestEnvironment testEnvironment) : base(testClass, typeInfo, testCases, diagnosticMessageSink, messageBus, testCaseOrderer, aggregator, cancellationTokenSource, collectionFixtureMappings) { _assemblyFixtureMappings = assemblyFixtureMappings; _testEnvironment = testEnvironment; }
public VsRemoteTestClassRunner(ITestClass testClass, IReflectionTypeInfo @class, ExceptionAggregator aggregator, Dictionary <Type, object> collectionFixtureMappings) : base(testClass, @class, Enumerable.Empty <IXunitTestCase>(), new NullMessageSink(), null, new DefaultTestCaseOrderer(new NullMessageSink()), aggregator, new CancellationTokenSource(), collectionFixtureMappings) { }
XElement CreateTestResultElement(ITestResultMessage testResult, string resultText) { ITest test = testResult.Test; ITestCase testCase = testResult.TestCase; ITestMethod testMethod = testCase.TestMethod; ITestClass testClass = testMethod.TestClass; var collectionElement = GetTestCollectionElement(testClass.TestCollection); var testResultElement = new XElement("test", new XAttribute("name", XmlEscape(test.DisplayName)), new XAttribute("type", testClass.Class.Name), new XAttribute("method", testMethod.Method.Name), new XAttribute("time", testResult.ExecutionTime.ToString(CultureInfo.InvariantCulture)), new XAttribute("result", resultText) ); var testOutput = testResult.Output; if (!string.IsNullOrWhiteSpace(testOutput)) { testResultElement.Add(new XElement("output", new XCData(testOutput))); } ISourceInformation sourceInformation = testCase.SourceInformation; if (sourceInformation != null) { var fileName = sourceInformation.FileName; if (fileName != null) { testResultElement.Add(new XAttribute("source-file", fileName)); } var lineNumber = sourceInformation.LineNumber; if (lineNumber != null) { testResultElement.Add(new XAttribute("source-line", lineNumber.GetValueOrDefault())); } } var traits = testCase.Traits; if (traits != null && traits.Count > 0) { var traitsElement = new XElement("traits"); foreach (var keyValuePair in traits) { foreach (var val in keyValuePair.Value) { traitsElement.Add( new XElement("trait", new XAttribute("name", XmlEscape(keyValuePair.Key)), new XAttribute("value", XmlEscape(val)) ) ); } } testResultElement.Add(traitsElement); } collectionElement.Add(testResultElement); if (_logger != null) { _logger.LogMessage($"collectionElement: {collectionElement}"); } return(testResultElement); }
public CustomTestClassRunner(ITestClass testClass, IReflectionTypeInfo @class, IEnumerable <IXunitTestCase> testCases, IMessageSink diagnosticMessageSink, IMessageBus messageBus, ITestCaseOrderer testCaseOrderer, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource, IDictionary <Type, object> collectionFixtureMappings) : base(testClass, @class, testCases, diagnosticMessageSink, messageBus, testCaseOrderer, aggregator, cancellationTokenSource, collectionFixtureMappings) { }
/// <summary> /// Core implementation to discover unit tests in a given test class. /// </summary> /// <param name="testClass">The test class.</param> /// <param name="includeSourceInformation">Set to <c>true</c> to attempt to include source information.</param> /// <param name="messageBus">The message sink to send discovery messages to.</param> /// <param name="discoveryOptions">The options used by the test framework during discovery.</param> /// <returns>Returns <c>true</c> if discovery should continue; <c>false</c> otherwise.</returns> protected abstract bool FindTestsForType(ITestClass testClass, bool includeSourceInformation, IMessageBus messageBus, ITestFrameworkDiscoveryOptions discoveryOptions);
public void IncorrectException(Type expectedExceptionType, Type actualExceptionType, ITestClass test, ITestMethod method) { string message = String.Format(CultureInfo.CurrentCulture, Properties.UnitTestMessage.LogIncorrectExceptionType, actualExceptionType.Name, expectedExceptionType.Name); LogMessage m = Create(LogMessageType.Error, message); MarkUnitTestMessage(m); DecorateTestGranularity(m, TestGranularity.TestScenario); m[UnitTestLogDecorator.IncorrectExceptionMessage] = true; m[UnitTestLogDecorator.ExpectedExceptionType] = expectedExceptionType; m[UnitTestLogDecorator.ActualExceptionType] = actualExceptionType; m[UnitTestLogDecorator.TestClassMetadata] = test; m[UnitTestLogDecorator.TestMethodMetadata] = method; Enqueue(m); }
protected override Task <RunSummary> RunTestClassAsync(ITestClass testClass, IReflectionTypeInfo @class, IEnumerable <IXunitTestCase> testCases) { RunTestClassAsync_AggregatorResult = Aggregator.ToException(); return(Task.FromResult(new RunSummary())); }
protected override Task <RunSummary> RunTestClassAsync(ITestClass testClass, IReflectionTypeInfo @class, IEnumerable <IXunitTestCase> testCases) { return(new VsixTestClassRunner(_vs, testClass, @class, testCases, _diagnosticMessageSink, MessageBus, TestCaseOrderer, Aggregator, CancellationTokenSource, CollectionFixtureMappings).RunAsync()); }
/// <summary> /// Initializes a new instance of the <see cref="XunitTestMethod"/> class. /// </summary> public XunitTestMethod(ITestClass testClass, IMethodInfo method) { Method = method; TestClass = testClass; }
/// <summary> /// Initializes a new instance of the <see cref="TestClassMessage"/> class. /// </summary> internal TestClassMessage(ITestCase testCase, ITestClass testClass) : base(testCase, testClass.TestCollection) { TestClass = testClass; }
protected override Task <RunSummary> RunTestClassAsync(ITestClass testClass, IReflectionTypeInfo @class, IEnumerable <IXunitTestCase> testCases) => new DependencyInjectionTestClassRunner(_provider, testClass, @class, testCases, _diagnosticMessageSink, MessageBus, TestCaseOrderer, new ExceptionAggregator(Aggregator), CancellationTokenSource, CollectionFixtureMappings) .RunAsync();
/// <summary> /// Initializes a new instance of the <see cref="TestClassMessage"/> class. /// </summary> internal TestClassMessage(ITestCase testCase, ITestClass testClass) : base(testCase, testClass.TestCollection) { TestClass = testClass; }
public static async Task <RunSummary> RunAsync(CancellationToken token, Func <Task <RunSummary> >[] tasks, ITestClass testClass) { var summary = new RunSummary(); if (tasks.Length > 1 && IsParallelizable(testClass)) { var results = await Task.WhenAll(tasks.Select(task => RunOnThreadPool(token, task))); foreach (var result in results) { summary.Aggregate(result); } } else { foreach (var task in tasks) { summary.Aggregate(await task()); } } return(summary); }
protected sealed override bool FindTestsForType(ITestClass testClass, bool includeSourceInformation, IMessageBus messageBus, ITestFrameworkDiscoveryOptions discoveryOptions) { return FindTestsForClass(testClass, includeSourceInformation); }
protected sealed override bool FindTestsForType(ITestClass testClass, bool includeSourceInformation, IMessageBus messageBus, ITestFrameworkDiscoveryOptions discoveryOptions) { return(FindTestsForClass(testClass, includeSourceInformation)); }
/// <summary> /// Initializes a new instance of the TestMethodStartingEventArgs type. /// </summary> /// <param name="testMethod">The test method metadata.</param> /// <param name="testClass">The test class metadata.</param> /// <param name="harness">The test harness instance.</param> public TestMethodStartingEventArgs(ITestMethod testMethod, ITestClass testClass, UnitTestHarness harness) : base(harness) { TestMethod = testMethod; TestClass = testClass; }
public virtual bool FindTestsForClass(ITestClass testClass, bool includeSourceInformation = false) { using (var messageBus = new MessageBus(Visitor)) return(base.FindTestsForType(testClass, includeSourceInformation, messageBus, TestFrameworkOptions.ForDiscovery())); }
public virtual List<ITestMethod> GetTestMethods(ITestClass test, object instance) { List<ITestMethod> methods = new List<ITestMethod>(test.GetTestMethods()); // Get any dynamically provided test methods IProvideDynamicTestMethods provider = instance as IProvideDynamicTestMethods; if (provider != null) { IEnumerable<ITestMethod> dynamicTestMethods = provider.GetDynamicTestMethods(); if (dynamicTestMethods != null) { methods.AddRange(dynamicTestMethods); } } FilterTestMethods(methods); SortTestMethods(methods); return methods; }
public TestClass6(ITestClass myProperty) { MyProperty = myProperty; }
public TestCoreClass(ITestClass testClass) { TestClass = testClass; }
/// <summary> /// Creates a new TestClassManager. /// </summary> /// <param name="provider">The unit test provider.</param> /// <param name="filter">The run filter.</param> /// <param name="testClass">The test class metadata.</param> /// <param name="instance">The test class instance.</param> /// <returns>Returns a new TestClassManager.</returns> public TestClassManager CreateTestClassManager(IUnitTestProvider provider, TestRunFilter filter, ITestClass testClass, object instance) { return(new TestClassManager(filter, _harness, testClass, instance, provider)); }