How to use TestCollection method of Xunit.v3.Mocks class

Best Xunit code snippet using Xunit.v3.Mocks.TestCollection

Mocks.cs

Source:Mocks.cs

...252		AppDomainOption appDomain = AppDomainOption.Disabled,253		bool shadowCopy = false)254	{255		var assembly = new XunitProjectAssembly { AssemblyFilename = "testAssembly.dll", ConfigFilename = "testAssembly.dll.config" };256		var config = new TestAssemblyConfiguration { DiagnosticMessages = diagnosticMessages, MethodDisplay = Xunit.TestMethodDisplay.ClassAndMethod, MaxParallelThreads = 42, ParallelizeTestCollections = true, ShadowCopy = shadowCopy };257		var result = Substitute.For<ITestAssemblyDiscoveryStarting, InterfaceProxy<ITestAssemblyDiscoveryStarting>>();258		result.AppDomain.Returns(appDomain);259		result.Assembly.Returns(assembly);260		result.DiscoveryOptions.Returns(TestFrameworkOptions.ForDiscovery(config));261		result.ShadowCopy.Returns(shadowCopy);262		return result;263	}264	public static ITestAssemblyExecutionFinished TestAssemblyExecutionFinished(265		bool diagnosticMessages = false,266		int total = 2112,267		int failed = 42,268		int skipped = 8,269		int errors = 6,270		decimal time = 123.456M)271	{272		var assembly = new XunitProjectAssembly { AssemblyFilename = "testAssembly.dll", ConfigFilename = "testAssembly.dll.config" };273		var config = new TestAssemblyConfiguration { DiagnosticMessages = diagnosticMessages, ShadowCopy = true };274		var summary = new ExecutionSummary { Total = total, Failed = failed, Skipped = skipped, Errors = errors, Time = time };275		var result = Substitute.For<ITestAssemblyExecutionFinished, InterfaceProxy<ITestAssemblyExecutionFinished>>();276		result.Assembly.Returns(assembly);277		result.ExecutionOptions.Returns(TestFrameworkOptions.ForExecution(config));278		result.ExecutionSummary.Returns(summary);279		return result;280	}281	public static ITestAssemblyExecutionStarting TestAssemblyExecutionStarting(282		bool diagnosticMessages = false,283		string? assemblyFilename = null)284	{285		var assembly = new XunitProjectAssembly { AssemblyFilename = assemblyFilename ?? "testAssembly.dll", ConfigFilename = "testAssembly.dll.config" };286		var config = new TestAssemblyConfiguration { DiagnosticMessages = diagnosticMessages, MethodDisplay = Xunit.TestMethodDisplay.ClassAndMethod, MaxParallelThreads = 42, ParallelizeTestCollections = true, ShadowCopy = true };287		var result = Substitute.For<ITestAssemblyExecutionStarting, InterfaceProxy<ITestAssemblyExecutionStarting>>();288		result.Assembly.Returns(assembly);289		result.ExecutionOptions.Returns(TestFrameworkOptions.ForExecution(config));290		return result;291	}292	public static ITestAssemblyFinished TestAssemblyFinished(293		int testsRun = 2112,294		int testsFailed = 42,295		int testsSkipped = 6,296		decimal executionTime = 123.4567M)297	{298		var testAssembly = TestAssembly("testAssembly.dll");299		var result = Substitute.For<ITestAssemblyFinished, InterfaceProxy<ITestAssemblyFinished>>();300		result.TestAssembly.Returns(testAssembly);301		result.TestsRun.Returns(testsRun);302		result.TestsFailed.Returns(testsFailed);303		result.TestsSkipped.Returns(testsSkipped);304		result.ExecutionTime.Returns(executionTime);305		return result;306	}307	public static ITestAssemblyStarting TestAssemblyStarting()308	{309		var testAssembly = TestAssembly("testAssembly.dll");310		var result = Substitute.For<ITestAssemblyStarting, InterfaceProxy<ITestAssemblyStarting>>();311		result.TestAssembly.Returns(testAssembly);312		return result;313	}314	public static ITestCase TestCase(ITestCollection? collection = null)315	{316		if (collection == null)317			collection = TestCollection();318		var result = Substitute.For<ITestCase, InterfaceProxy<ITestCase>>();319		result.TestMethod.TestClass.TestCollection.Returns(collection);320		return result;321	}322	public static ITestCase TestCase(ITestMethod testMethod)323	{324		var result = Substitute.For<ITestCase, InterfaceProxy<ITestCase>>();325		result.TestMethod.Returns(testMethod);326		return result;327	}328	public static ITestCase TestCase<TClassUnderTest>(329		string methodName,330		string? displayName = null,331		string? skipReason = null,332		string? uniqueID = null,333		string? fileName = null,334		int? lineNumber = null)335	{336		return TestCase(typeof(TClassUnderTest), methodName, displayName, skipReason, uniqueID, fileName, lineNumber);337	}338	public static ITestCase TestCase(339		Type type,340		string methodName,341		string? displayName = null,342		string? skipReason = null,343		string? uniqueID = null,344		string? fileName = null,345		int? lineNumber = null)346	{347		var testMethod = TestMethod(type, methodName);348		var traits = GetTraits(testMethod.Method);349		var result = Substitute.For<ITestCase, InterfaceProxy<ITestCase>>();350		result.DisplayName.Returns(displayName ?? $"{type}.{methodName}");351		result.SkipReason.Returns(skipReason);352		result.TestMethod.Returns(testMethod);353		result.Traits.Returns(traits);354		result.UniqueID.Returns(uniqueID ?? Guid.NewGuid().ToString());355		if (fileName != null && lineNumber != null)356		{357			var sourceInfo = new Xunit.SourceInformation { FileName = fileName, LineNumber = lineNumber };358			result.SourceInformation.Returns(sourceInfo);359		}360		return result;361	}362	public static IReflectionAttributeInfo TestCaseOrdererAttribute(string typeName, string assemblyName)363	{364		var result = Substitute.For<IReflectionAttributeInfo, InterfaceProxy<IReflectionAttributeInfo>>();365		result.Attribute.Returns(new TestCaseOrdererAttribute(typeName, assemblyName));366		result.GetConstructorArguments().Returns(new object[] { typeName, assemblyName });367		return result;368	}369	public static IReflectionAttributeInfo TestCaseOrdererAttribute(Type type)370	{371		var result = Substitute.For<IReflectionAttributeInfo, InterfaceProxy<IReflectionAttributeInfo>>();372		result.Attribute.Returns(new TestCaseOrdererAttribute(type));373		result.GetConstructorArguments().Returns(new object[] { type });374		return result;375	}376	public static IReflectionAttributeInfo TestCaseOrdererAttribute<TOrderer>() =>377		TestCaseOrdererAttribute(typeof(TOrderer));378	public static ITestClass TestClass(379		string? typeName = null,380		IReflectionAttributeInfo[]? attributes = null)381	{382		var testCollection = TestCollection();383		var typeInfo = TypeInfo(typeName, attributes: attributes);384		var result = Substitute.For<ITestClass, InterfaceProxy<ITestClass>>();385		result.Class.Returns(typeInfo);386		result.TestCollection.Returns(testCollection);387		return result;388	}389	public static TestClass TestClass(390		Type type,391		ITestCollection? collection = null)392	{393		if (collection == null)394			collection = TestCollection(type.Assembly);395		return new TestClass(collection, Reflector.Wrap(type));396	}397	public static TestCollection TestCollection(398		Assembly? assembly = null,399		ITypeInfo? definition = null,400		string? displayName = null)401	{402		if (assembly == null)403			assembly = typeof(Mocks).Assembly;404		if (displayName == null)405			displayName = "Mock test collection for " + assembly.CodeBase;406		return new TestCollection(TestAssembly(assembly), definition, displayName);407	}408	public static ITestCollectionFinished TestCollectionFinished(409		string displayName = "Display Name",410		int testsRun = 2112,411		int testsFailed = 42,412		int testsSkipped = 6,413		decimal executionTime = 123.4567M)414	{415		var result = Substitute.For<ITestCollectionFinished, InterfaceProxy<ITestCollectionFinished>>();416		result.TestsRun.Returns(testsRun);417		result.TestsFailed.Returns(testsFailed);418		result.TestsSkipped.Returns(testsSkipped);419		result.ExecutionTime.Returns(executionTime);420		result.TestCollection.DisplayName.Returns(displayName);421		return result;422	}423	public static ITestCollectionStarting TestCollectionStarting()424	{425		var result = Substitute.For<ITestCollectionStarting, InterfaceProxy<ITestCollectionStarting>>();426		result.TestCollection.DisplayName.Returns("Display Name");427		return result;428	}429	public static IReflectionAttributeInfo TestCollectionOrdererAttribute(string typeName, string assemblyName)430	{431		var result = Substitute.For<IReflectionAttributeInfo, InterfaceProxy<IReflectionAttributeInfo>>();432		result.Attribute.Returns(new TestCollectionOrdererAttribute(typeName, assemblyName));433		result.GetConstructorArguments().Returns(new object[] { typeName, assemblyName });434		return result;435	}436	public static IReflectionAttributeInfo TestCollectionOrdererAttribute(Type type)437	{438		var result = Substitute.For<IReflectionAttributeInfo, InterfaceProxy<IReflectionAttributeInfo>>();439		result.Attribute.Returns(new TestCollectionOrdererAttribute(type));440		result.GetConstructorArguments().Returns(new object[] { type });441		return result;442	}443	public static IReflectionAttributeInfo TestCollectionOrdererAttribute<TOrderer>() =>444		TestCollectionOrdererAttribute(typeof(TOrderer));445	public static ITestFailed TestFailed(446		Type type,447		string methodName,448		string? displayName = null,449		string? output = null,450		decimal executionTime = 0M,451		Exception? ex = null)452	{453		var testCase = TestCase(type, methodName);454		var test = Test(testCase, displayName ?? "NO DISPLAY NAME");455		var failureInfo = Xunit.Sdk.ExceptionUtility.ConvertExceptionToFailureInformation(ex ?? new Exception());456		var result = Substitute.For<ITestFailed, InterfaceProxy<ITestFailed>>();457		result.ExceptionParentIndices.Returns(failureInfo.ExceptionParentIndices);458		result.ExceptionTypes.Returns(failureInfo.ExceptionTypes);459		result.ExecutionTime.Returns(executionTime);460		result.Messages.Returns(failureInfo.Messages);461		result.Output.Returns(output);462		result.StackTraces.Returns(failureInfo.StackTraces);463		result.TestCase.Returns(testCase);464		result.Test.Returns(test);465		return result;466	}467	public static ITestFailed TestFailed(468		string displayName,469		decimal executionTime,470		string? exceptionType = null,471		string? exceptionMessage = null,472		string? stackTrace = null,473		string? output = null)474	{475		var testCase = TestCase();476		var test = Test(testCase, displayName);477		var result = Substitute.For<ITestFailed, InterfaceProxy<ITestFailed>>();478		result.ExceptionParentIndices.Returns(new[] { -1 });479		result.ExceptionTypes.Returns(new[] { exceptionType });480		result.ExecutionTime.Returns(executionTime);481		result.Messages.Returns(new[] { exceptionMessage });482		result.Output.Returns(output);483		result.StackTraces.Returns(new[] { stackTrace });484		result.TestCase.Returns(testCase);485		result.Test.Returns(test);486		return result;487	}488	public static IReflectionAttributeInfo TestFrameworkAttribute(Type type)489	{490		var attribute = Activator.CreateInstance(type);491		if (attribute == null)492			throw new InvalidOperationException($"Unable to create attribute instance: '{type.FullName}'");493		var result = Substitute.For<IReflectionAttributeInfo, InterfaceProxy<IReflectionAttributeInfo>>();494		result.Attribute.Returns(attribute);495		result.GetCustomAttributes(null).ReturnsForAnyArgs(496			callInfo => LookupAttribute(497				callInfo.Arg<string>(),498				CustomAttributeData.GetCustomAttributes(attribute.GetType()).Select(x => Reflector.Wrap(x)).ToArray()499			)500		);501		return result;502	}503	public static ITestMethod TestMethod(504		string? typeName = null,505		string? methodName = null,506		string? displayName = null,507		string? skip = null,508		int timeout = 0,509		IEnumerable<IParameterInfo>? parameters = null,510		IEnumerable<IReflectionAttributeInfo>? classAttributes = null,511		IEnumerable<IReflectionAttributeInfo>? methodAttributes = null)512	{513		if (classAttributes == null)514			classAttributes = Enumerable.Empty<IReflectionAttributeInfo>();515		if (methodAttributes == null)516			methodAttributes = Enumerable.Empty<IReflectionAttributeInfo>();517		if (parameters == null)518			parameters = Enumerable.Empty<IParameterInfo>();519		var factAttribute = methodAttributes.FirstOrDefault(attr => typeof(FactAttribute).IsAssignableFrom(attr.Attribute.GetType()));520		if (factAttribute == null)521		{522			factAttribute = FactAttribute(displayName, skip, timeout);523			methodAttributes = methodAttributes.Concat(new[] { factAttribute });524		}525		var testClass = TestClass(typeName, attributes: classAttributes.ToArray());526		var methodInfo = MethodInfo(methodName, methodAttributes.ToArray(), parameters.ToArray(), testClass.Class);527		var result = Substitute.For<ITestMethod, InterfaceProxy<ITestMethod>>();528		result.Method.Returns(methodInfo);529		result.TestClass.Returns(testClass);530		return result;531	}532	public static TestMethod TestMethod(533		Type type,534		string methodName,535		ITestCollection? collection = null)536	{537		var @class = TestClass(type, collection);538		var methodInfo = type.GetMethod(methodName);539		if (methodInfo == null)540			throw new Exception($"Unknown method: {type.FullName}.{methodName}");541		return new TestMethod(@class, Reflector.Wrap(methodInfo));542	}543	public static ITestPassed TestPassed(544		Type type,545		string methodName,546		string? displayName = null,547		string? output = null,548		decimal executionTime = 0M)549	{550		var testCase = TestCase(type, methodName);551		var test = Test(testCase, displayName ?? "NO DISPLAY NAME");552		var result = Substitute.For<ITestPassed, InterfaceProxy<ITestPassed>>();553		result.ExecutionTime.Returns(executionTime);554		result.Output.Returns(output);555		result.TestCase.Returns(testCase);556		result.Test.Returns(test);557		return result;558	}559	public static ITestPassed TestPassed(560		string displayName,561		string? output = null)562	{563		var testCase = TestCase();564		var test = Test(testCase, displayName);565		var result = Substitute.For<ITestPassed, InterfaceProxy<ITestPassed>>();566		result.Test.Returns(test);567		result.ExecutionTime.Returns(1.2345M);568		result.Output.Returns(output);569		return result;570	}571	public static ITestResultMessage TestResult<TClassUnderTest>(572		string methodName,573		string displayName,574		decimal executionTime)575	{576		var testCase = TestCase<TClassUnderTest>(methodName);577		var test = Test(testCase, displayName);578		var result = Substitute.For<ITestResultMessage, InterfaceProxy<ITestResultMessage>>();579		result.TestCase.Returns(testCase);580		result.Test.Returns(test);581		result.ExecutionTime.Returns(executionTime);582		return result;583	}584	public static ITestSkipped TestSkipped(585		Type type,586		string methodName,587		string? displayName = null,588		string? output = null,589		decimal executionTime = 0M,590		string? skipReason = null)591	{592		var testCase = TestCase(type, methodName);593		var test = Test(testCase, displayName ?? "NO DISPLAY NAME");594		var result = Substitute.For<ITestSkipped, InterfaceProxy<ITestSkipped>>();595		result.ExecutionTime.Returns(executionTime);596		result.Output.Returns(output);597		result.Reason.Returns(skipReason);598		result.TestCase.Returns(testCase);599		result.Test.Returns(test);600		return result;601	}602	public static ITestSkipped TestSkipped(603		string displayName,604		string? skipReason = null)605	{606		var testCase = TestCase();607		var test = Test(testCase, displayName);608		var result = Substitute.For<ITestSkipped, InterfaceProxy<ITestSkipped>>();609		result.Reason.Returns(skipReason);610		result.TestCase.Returns(testCase);611		result.Test.Returns(test);612		return result;613	}614	public static ITestStarting TestStarting(string displayName)615	{616		var testCase = TestCase();617		var test = Test(testCase, displayName);618		var result = Substitute.For<ITestStarting, InterfaceProxy<ITestStarting>>();619		result.Test.Returns(test);620		return result;621	}622	public static IReflectionAttributeInfo TheoryAttribute(623		string? displayName = null,624		string? skip = null,625		int timeout = 0)626	{627		var result = Substitute.For<IReflectionAttributeInfo, InterfaceProxy<IReflectionAttributeInfo>>();628		result.Attribute.Returns(new TheoryAttribute { DisplayName = displayName, Skip = skip });629		result.GetNamedArgument<string>("DisplayName").Returns(displayName);630		result.GetNamedArgument<string>("Skip").Returns(skip);631		result.GetNamedArgument<int>("Timeout").Returns(timeout);632		return result;633	}634	public static IReflectionAttributeInfo TraitAttribute<T>()635		where T : Attribute, new()636	{637		var result = Substitute.For<IReflectionAttributeInfo, InterfaceProxy<IReflectionAttributeInfo>>();638		result.Attribute.Returns(new T());639		return result;640	}641	public static IReflectionAttributeInfo TraitAttribute(642		string name,643		string value)644	{645		var result = Substitute.For<IReflectionAttributeInfo, InterfaceProxy<IReflectionAttributeInfo>>();646		var traitDiscovererAttributes = new[] { TraitDiscovererAttribute() };647		result.GetCustomAttributes(typeof(TraitDiscovererAttribute)).Returns(traitDiscovererAttributes);648		result.Attribute.Returns(new TraitAttribute(name, value));649		result.GetConstructorArguments().Returns(new object[] { name, value });650		return result;651	}652	public static IAttributeInfo TraitDiscovererAttribute(653		string typeName = "Xunit.Sdk.TraitDiscoverer",654		string assemblyName = "xunit.v3.core")655	{656		var result = Substitute.For<IReflectionAttributeInfo, InterfaceProxy<IReflectionAttributeInfo>>();657		result.Attribute.Returns(new TraitDiscovererAttribute(typeName, assemblyName));658		result.GetConstructorArguments().Returns(new object[] { typeName, assemblyName });659		return result;660	}661	public static IAttributeInfo TraitDiscovererAttribute(Type discovererType)662	{663		var result = Substitute.For<IReflectionAttributeInfo, InterfaceProxy<IReflectionAttributeInfo>>();664		result.Attribute.Returns(new TraitDiscovererAttribute(discovererType));665		result.GetConstructorArguments().Returns(new object[] { discovererType });666		return result;667	}668	public static IAttributeInfo TraitDiscovererAttribute<TDiscoverer>() =>669		TraitDiscovererAttribute(typeof(TDiscoverer));670	public static ITypeInfo TypeInfo(671		string? typeName = null,672		IMethodInfo[]? methods = null,673		IReflectionAttributeInfo[]? attributes = null,674		string? assemblyFileName = null)675	{676		var result = Substitute.For<ITypeInfo, InterfaceProxy<ITypeInfo>>();677		result.Name.Returns(typeName ?? "type:" + Guid.NewGuid().ToString("n"));678		result.GetMethods(false).ReturnsForAnyArgs(methods ?? new IMethodInfo[0]);679		var assemblyInfo = AssemblyInfo(assemblyFileName: assemblyFileName);680		result.Assembly.Returns(assemblyInfo);681		result.GetCustomAttributes("").ReturnsForAnyArgs(callInfo => LookupAttribute(callInfo.Arg<string>(), attributes));682		return result;683	}684	public static XunitTestCase XunitTestCase<TClassUnderTest>(685		string methodName,686		ITestCollection? collection = null,687		object[]? testMethodArguments = null,688		IMessageSink? diagnosticMessageSink = null)689	{690		var method = TestMethod(typeof(TClassUnderTest), methodName, collection);691		return new XunitTestCase(diagnosticMessageSink ?? new NullMessageSink(), TestMethodDisplay.ClassAndMethod, TestMethodDisplayOptions.None, method, testMethodArguments);692	}693	public static XunitTheoryTestCase XunitTheoryTestCase<TClassUnderTest>(694		string methodName,695		ITestCollection? collection = null,696		IMessageSink? diagnosticMessageSink = null)697	{698		var method = TestMethod(typeof(TClassUnderTest), methodName, collection);699		return new XunitTheoryTestCase(diagnosticMessageSink ?? new NullMessageSink(), TestMethodDisplay.ClassAndMethod, TestMethodDisplayOptions.None, method);700	}701	// Helpers702	static Dictionary<string, List<string>> GetTraits(IMethodInfo method)703	{704		var result = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);705		foreach (var traitAttribute in method.GetCustomAttributes(typeof(TraitAttribute)))706		{707			var ctorArgs = traitAttribute.GetConstructorArguments().ToList();708			result.Add((string)ctorArgs[0], (string)ctorArgs[1]);709		}...

TestAssemblyRunnerTests.cs

Source:TestAssemblyRunnerTests.cs

...54				}55			);56		}57		[Fact]58		public static async ValueTask FailureInQueueOfTestAssemblyStarting_DoesNotQueueTestAssemblyFinished_DoesNotRunTestCollections()59		{60			var messages = new List<_MessageSinkMessage>();61			var messageSink = Substitute.For<_IMessageSink>();62			messageSink63				.OnMessage(null!)64				.ReturnsForAnyArgs(callInfo =>65				{66					var msg = callInfo.Arg<_MessageSinkMessage>();67					messages.Add(msg);68					if (msg is _TestAssemblyStarting)69						throw new InvalidOperationException();70					return true;71				});72			var runner = TestableTestAssemblyRunner.Create(messageSink);73			var ex = await Record.ExceptionAsync(() => runner.RunAsync());74			Assert.IsType<InvalidOperationException>(ex);75			var starting = Assert.Single(messages);76			Assert.IsAssignableFrom<_TestAssemblyStarting>(starting);77			Assert.Empty(runner.CollectionsRun);78		}79		[Fact]80		public static async ValueTask FailureInAfterTestAssemblyStarting_GivesErroredAggregatorToTestCollectionRunner_NoCleanupFailureMessage()81		{82			var messages = new List<_MessageSinkMessage>();83			var messageSink = SpyMessageSink.Create(messages: messages);84			var runner = TestableTestAssemblyRunner.Create(messageSink);85			var ex = new DivideByZeroException();86			runner.AfterTestAssemblyStarting_Callback = aggregator => aggregator.Add(ex);87			await runner.RunAsync();88			Assert.Same(ex, runner.RunTestCollectionAsync_AggregatorResult);89			Assert.Empty(messages.OfType<_TestAssemblyCleanupFailure>());90		}91		[Fact]92		public static async ValueTask FailureInBeforeTestAssemblyFinished_ReportsCleanupFailure_DoesNotIncludeExceptionsFromAfterTestAssemblyStarting()93		{94			var thisAssembly = Assembly.GetExecutingAssembly();95			var messages = new List<_MessageSinkMessage>();96			var messageSink = SpyMessageSink.Create(messages: messages);97			var testCases = new[] { TestCaseForTestCollection() };98			var runner = TestableTestAssemblyRunner.Create(messageSink, testCases: testCases);99			var startingException = new DivideByZeroException();100			var finishedException = new InvalidOperationException();101			runner.AfterTestAssemblyStarting_Callback = aggregator => aggregator.Add(startingException);102			runner.BeforeTestAssemblyFinished_Callback = aggregator => aggregator.Add(finishedException);103			await runner.RunAsync();104			var assemblyStarting = Assert.Single(messages.OfType<_TestAssemblyStarting>());105			var cleanupFailure = Assert.Single(messages.OfType<_TestAssemblyCleanupFailure>());106#if NETFRAMEWORK107			Assert.Equal(thisAssembly.GetLocalCodeBase(), assemblyStarting.AssemblyPath);108			Assert.Equal(runner.TestAssembly.ConfigFileName, assemblyStarting.ConfigFilePath);109#endif110			Assert.Equal(typeof(InvalidOperationException).FullName, cleanupFailure.ExceptionTypes.Single());111		}112		[Fact]113		public static async ValueTask Cancellation_TestAssemblyStarting_DoesNotCallExtensibilityCallbacks()114		{115			var messageSink = SpyMessageSink.Create(msg => !(msg is _TestAssemblyStarting));116			var runner = TestableTestAssemblyRunner.Create(messageSink);117			await runner.RunAsync();118			Assert.False(runner.AfterTestAssemblyStarting_Called);119			Assert.False(runner.BeforeTestAssemblyFinished_Called);120		}121		[Fact]122		public static async ValueTask Cancellation_TestAssemblyFinished_CallsCallExtensibilityCallbacks()123		{124			var messageSink = SpyMessageSink.Create(msg => !(msg is _TestAssemblyFinished));125			var runner = TestableTestAssemblyRunner.Create(messageSink);126			await runner.RunAsync();127			Assert.True(runner.AfterTestAssemblyStarting_Called);128			Assert.True(runner.BeforeTestAssemblyFinished_Called);129		}130		[Fact]131		public static async ValueTask TestsAreGroupedByCollection()132		{133			var collection1 = Mocks.TestCollection(displayName: "1", uniqueID: "collection-1");134			var testCase1a = TestCaseForTestCollection(collection1);135			var testCase1b = TestCaseForTestCollection(collection1);136			var collection2 = Mocks.TestCollection(displayName: "2", uniqueID: "collection-2");137			var testCase2a = TestCaseForTestCollection(collection2);138			var testCase2b = TestCaseForTestCollection(collection2);139			var runner = TestableTestAssemblyRunner.Create(testCases: new[] { testCase1a, testCase2a, testCase2b, testCase1b });140			await runner.RunAsync();141			Assert.Collection(142				runner.CollectionsRun.OrderBy(c => c.Item1.DisplayName),143				tuple =>144				{145					Assert.Same(collection1, tuple.Item1);146					Assert.Collection(tuple.Item2,147						testCase => Assert.Same(testCase1a, testCase),148						testCase => Assert.Same(testCase1b, testCase)149					);150				},151				tuple =>152				{153					Assert.Same(collection2, tuple.Item1);154					Assert.Collection(tuple.Item2,155						testCase => Assert.Same(testCase2a, testCase),156						testCase => Assert.Same(testCase2b, testCase)157					);158				}159			);160		}161		[Fact]162		public static async void SignalingCancellationStopsRunningCollections()163		{164			var collection1 = Mocks.TestCollection();165			var testCase1 = TestCaseForTestCollection(collection1);166			var collection2 = Mocks.TestCollection();167			var testCase2 = TestCaseForTestCollection(collection2);168			var runner = TestableTestAssemblyRunner.Create(testCases: new[] { testCase1, testCase2 }, cancelInRunTestCollectionAsync: true);169			await runner.RunAsync();170			Assert.Single(runner.CollectionsRun);171		}172		[Fact]173		public static async void TestContextInspection()174		{175			var runner = TestableTestAssemblyRunner.Create();176			await runner.RunAsync();177			Assert.NotNull(runner.AfterTestAssemblyStarting_Context);178			Assert.Equal(TestEngineStatus.Initializing, runner.AfterTestAssemblyStarting_Context.TestAssemblyStatus);179			Assert.Equal(TestPipelineStage.TestAssemblyExecution, runner.AfterTestAssemblyStarting_Context.PipelineStage);180			Assert.Null(runner.AfterTestAssemblyStarting_Context.TestCollectionStatus);181			Assert.Null(runner.AfterTestAssemblyStarting_Context.TestClassStatus);182			Assert.Null(runner.AfterTestAssemblyStarting_Context.TestMethodStatus);183			Assert.Null(runner.AfterTestAssemblyStarting_Context.TestCaseStatus);184			Assert.Null(runner.AfterTestAssemblyStarting_Context.TestStatus);185			Assert.Same(runner.TestAssembly, runner.AfterTestAssemblyStarting_Context.TestAssembly);186			Assert.NotNull(runner.RunTestCollectionAsync_Context);187			Assert.Equal(TestEngineStatus.Running, runner.RunTestCollectionAsync_Context.TestAssemblyStatus);188			Assert.Null(runner.RunTestCollectionAsync_Context.TestCollectionStatus);189			Assert.Null(runner.RunTestCollectionAsync_Context.TestClassStatus);190			Assert.Null(runner.RunTestCollectionAsync_Context.TestMethodStatus);191			Assert.Null(runner.RunTestCollectionAsync_Context.TestCaseStatus);192			Assert.Null(runner.RunTestCollectionAsync_Context.TestStatus);193			Assert.Same(runner.TestAssembly, runner.RunTestCollectionAsync_Context.TestAssembly);194			Assert.NotNull(runner.BeforeTestAssemblyFinished_Context);195			Assert.Equal(TestEngineStatus.CleaningUp, runner.BeforeTestAssemblyFinished_Context.TestAssemblyStatus);196			Assert.Null(runner.BeforeTestAssemblyFinished_Context.TestCollectionStatus);197			Assert.Null(runner.BeforeTestAssemblyFinished_Context.TestClassStatus);198			Assert.Null(runner.BeforeTestAssemblyFinished_Context.TestMethodStatus);199			Assert.Null(runner.BeforeTestAssemblyFinished_Context.TestCaseStatus);200			Assert.Null(runner.BeforeTestAssemblyFinished_Context.TestStatus);201			Assert.Same(runner.TestAssembly, runner.BeforeTestAssemblyFinished_Context.TestAssembly);202		}203	}204	public class TestCaseOrderer205	{206		[Fact]207		public static void DefaultTestCaseOrderer()208		{209			var runner = TestableTestAssemblyRunner.Create();210			Assert.IsType<DefaultTestCaseOrderer>(runner.DefaultTestCaseOrderer);211		}212	}213	public class TestCollectionOrderer214	{215		[Fact]216		public static void DefaultTestCollectionOrderer()217		{218			var runner = TestableTestAssemblyRunner.Create();219			Assert.IsType<DefaultTestCollectionOrderer>(runner.DefaultTestCollectionOrderer);220		}221		[Fact]222		public static async ValueTask OrdererUsedToOrderTestCollections()223		{224			var collection1 = Mocks.TestCollection(displayName: "AAA", uniqueID: "collection-1");225			var testCase1a = TestCaseForTestCollection(collection1);226			var testCase1b = TestCaseForTestCollection(collection1);227			var collection2 = Mocks.TestCollection(displayName: "ZZZZ", uniqueID: "collection-2");228			var testCase2a = TestCaseForTestCollection(collection2);229			var testCase2b = TestCaseForTestCollection(collection2);230			var collection3 = Mocks.TestCollection(displayName: "MM", uniqueID: "collection-3");231			var testCase3a = TestCaseForTestCollection(collection3);232			var testCase3b = TestCaseForTestCollection(collection3);233			var testCases = new[] { testCase1a, testCase3a, testCase2a, testCase3b, testCase2b, testCase1b };234			var runner = TestableTestAssemblyRunner.Create(testCases: testCases, testCollectionOrderer: new DescendingDisplayNameCollectionOrderer());235			await runner.RunAsync();236			Assert.Collection(237				runner.CollectionsRun,238				collection =>239				{240					Assert.Same(collection2, collection.Item1);241					Assert.Equal(new[] { testCase2a, testCase2b }, collection.Item2);242				},243				collection =>244				{245					Assert.Same(collection3, collection.Item1);246					Assert.Equal(new[] { testCase3a, testCase3b }, collection.Item2);247				},248				collection =>249				{250					Assert.Same(collection1, collection.Item1);251					Assert.Equal(new[] { testCase1a, testCase1b }, collection.Item2);252				}253			);254		}255		class DescendingDisplayNameCollectionOrderer : ITestCollectionOrderer256		{257			public IReadOnlyCollection<_ITestCollection> OrderTestCollections(IReadOnlyCollection<_ITestCollection> TestCollections) =>258				TestCollections259					.OrderByDescending(c => c.DisplayName)260					.CastOrToReadOnlyCollection();261		}262		[Fact]263		public static async ValueTask TestCaseOrdererWhichThrowsLogsMessageAndDoesNotReorderTestCollections()264		{265			var spy = SpyMessageSink.Capture();266			TestContext.Current!.DiagnosticMessageSink = spy;267			var collection1 = Mocks.TestCollection(displayName: "AAA", uniqueID: "collection-1");268			var testCase1 = TestCaseForTestCollection(collection1);269			var collection2 = Mocks.TestCollection(displayName: "ZZZZ", uniqueID: "collection-2");270			var testCase2 = TestCaseForTestCollection(collection2);271			var collection3 = Mocks.TestCollection(displayName: "MM", uniqueID: "collection-3");272			var testCase3 = TestCaseForTestCollection(collection3);273			var testCases = new[] { testCase1, testCase2, testCase3 };274			var runner = TestableTestAssemblyRunner.Create(testCases: testCases, testCollectionOrderer: new ThrowingCollectionOrderer());275			await runner.RunAsync();276			Assert.Collection(277				runner.CollectionsRun,278				collection => Assert.Same(collection1, collection.Item1),279				collection => Assert.Same(collection2, collection.Item1),280				collection => Assert.Same(collection3, collection.Item1)281			);282			var diagnosticMessage = Assert.Single(spy.Messages.OfType<_DiagnosticMessage>());283			Assert.StartsWith("Test collection orderer 'TestAssemblyRunnerTests+TestCollectionOrderer+ThrowingCollectionOrderer' threw 'System.DivideByZeroException' during ordering: Attempted to divide by zero.", diagnosticMessage.Message);284		}285		class ThrowingCollectionOrderer : ITestCollectionOrderer286		{287			public IReadOnlyCollection<_ITestCollection> OrderTestCollections(IReadOnlyCollection<_ITestCollection> testCollections)288			{289				throw new DivideByZeroException();290			}291		}292	}293	class TestableTestAssemblyRunnerContext : TestAssemblyRunnerContext<_ITestCase>294	{295		public TestableTestAssemblyRunnerContext(296			_ITestAssembly testAssembly,297			IReadOnlyCollection<_ITestCase> testCases,298			_IMessageSink executionMessageSink,299			_ITestFrameworkExecutionOptions executionOptions) :300				base(testAssembly, testCases, executionMessageSink, executionOptions)301		{ }302		public override string TestFrameworkDisplayName =>303			"The test framework display name";304		public override string TestFrameworkEnvironment =>305			"The test framework environment";306		// Use the sync message bus, so that we can immediately react to cancellations307		protected override IMessageBus CreateMessageBus() =>308			new SynchronousMessageBus(ExecutionMessageSink);309	}310	class TestableTestAssemblyRunner : TestAssemblyRunner<TestableTestAssemblyRunnerContext, _ITestCase>311	{312		readonly bool cancelInRunTestCollectionAsync;313		readonly TestableTestAssemblyRunnerContext ctxt;314		readonly RunSummary result;315		readonly ITestCollectionOrderer? testCollectionOrderer;316		public List<Tuple<_ITestCollection, IReadOnlyCollection<_ITestCase>>> CollectionsRun = new();317		public Action<ExceptionAggregator> AfterTestAssemblyStarting_Callback = _ => { };318		public bool AfterTestAssemblyStarting_Called;319		public TestContext? AfterTestAssemblyStarting_Context;320		public Action<ExceptionAggregator> BeforeTestAssemblyFinished_Callback = _ => { };321		public bool BeforeTestAssemblyFinished_Called;322		public TestContext? BeforeTestAssemblyFinished_Context;323		public ITestCaseOrderer DefaultTestCaseOrderer;324		public ITestCollectionOrderer DefaultTestCollectionOrderer;325		public Exception? RunTestCollectionAsync_AggregatorResult;326		public TestContext? RunTestCollectionAsync_Context;327		TestableTestAssemblyRunner(328			TestableTestAssemblyRunnerContext ctxt,329			RunSummary result,330			bool cancelInRunTestCollectionAsync,331			ITestCollectionOrderer? testCollectionOrderer)332		{333			DefaultTestCaseOrderer = GetTestCaseOrderer(ctxt);334			DefaultTestCollectionOrderer = GetTestCollectionOrderer(ctxt);335			this.ctxt = ctxt;336			this.result = result;337			this.cancelInRunTestCollectionAsync = cancelInRunTestCollectionAsync;338			this.testCollectionOrderer = testCollectionOrderer;339		}340		public static TestableTestAssemblyRunner Create(341			_IMessageSink? executionMessageSink = null,342			RunSummary? result = null,343			_ITestCase[]? testCases = null,344			_ITestFrameworkExecutionOptions? executionOptions = null,345			bool cancelInRunTestCollectionAsync = false,346			ITestCollectionOrderer? testCollectionOrderer = null)347		{348			var ctxt = new TestableTestAssemblyRunnerContext(349				Mocks.TestAssembly(Assembly.GetExecutingAssembly()),350				testCases ?? new[] { Substitute.For<_ITestCase>() },  // Need at least one so it calls RunTestCollectionAsync351				executionMessageSink ?? SpyMessageSink.Create(),352				executionOptions ?? _TestFrameworkOptions.ForExecution()353			);354			return new(ctxt, result ?? new RunSummary(), cancelInRunTestCollectionAsync, testCollectionOrderer);355		}356		public _ITestAssembly TestAssembly => ctxt.TestAssembly;357		protected override ITestCollectionOrderer GetTestCollectionOrderer(TestableTestAssemblyRunnerContext ctxt) =>358			testCollectionOrderer ?? base.GetTestCollectionOrderer(ctxt);359		protected override ValueTask AfterTestAssemblyStartingAsync(TestableTestAssemblyRunnerContext ctxt)360		{361			AfterTestAssemblyStarting_Called = true;362			AfterTestAssemblyStarting_Context = TestContext.Current;363			AfterTestAssemblyStarting_Callback(ctxt.Aggregator);364			return default;365		}366		protected override ValueTask BeforeTestAssemblyFinishedAsync(TestableTestAssemblyRunnerContext ctxt)367		{368			BeforeTestAssemblyFinished_Called = true;369			BeforeTestAssemblyFinished_Context = TestContext.Current;370			BeforeTestAssemblyFinished_Callback(ctxt.Aggregator);371			return default;372		}373		public ValueTask<RunSummary> RunAsync() =>374			RunAsync(ctxt);375		protected override ValueTask<RunSummary> RunTestCollectionAsync(376			TestableTestAssemblyRunnerContext ctxt,377			_ITestCollection testCollection,378			IReadOnlyCollection<_ITestCase> testCases)379		{380			if (cancelInRunTestCollectionAsync)381				ctxt.CancellationTokenSource.Cancel();382			RunTestCollectionAsync_AggregatorResult = ctxt.Aggregator.ToException();383			RunTestCollectionAsync_Context = TestContext.Current;384			CollectionsRun.Add(Tuple.Create(testCollection, testCases));385			return new(result);386		}387	}388	static _ITestCase TestCaseForTestCollection(_ITestCollection? collection = null)389	{390		collection ??= Mocks.TestCollection();391		var result = Substitute.For<_ITestCase, InterfaceProxy<_ITestCase>>();392		result.TestCollection.Returns(collection);393		return result;394	}395}...

XunitTestCollectionRunnerTests.cs

Source:XunitTestCollectionRunnerTests.cs

...5using System.Threading.Tasks;6using Xunit;7using Xunit.Sdk;8using Xunit.v3;9public class XunitTestCollectionRunnerTests10{11	[Fact]12	public static async void CreatesFixtures()13	{14		var collection = new TestCollection(Mocks.TestAssembly(), Reflector.Wrap(typeof(CollectionUnderTest)), "Mock Test Collection");15		var testCase = TestData.XunitTestCase<XunitTestCollectionRunnerTests>("CreatesFixtures", collection);16		var runner = TestableXunitTestCollectionRunner.Create(testCase);17		await runner.RunAsync();18		Assert.NotNull(runner.RunTestClassesAsync_CollectionFixtureMappings);19		Assert.Collection(20			runner.RunTestClassesAsync_CollectionFixtureMappings.OrderBy(mapping => mapping.Key.Name),21			mapping => Assert.IsType<FixtureUnderTest>(mapping.Value),22			mapping => Assert.IsType<object>(mapping.Value)23		);24	}25	[Fact]26	public static async void DisposesFixtures()27	{28		var collection = new TestCollection(Mocks.TestAssembly(), Reflector.Wrap(typeof(CollectionUnderTest)), "Mock Test Collection");29		var testCase = TestData.XunitTestCase<XunitTestCollectionRunnerTests>("DisposesFixtures", collection);30		var runner = TestableXunitTestCollectionRunner.Create(testCase);31		await runner.RunAsync();32		Assert.NotNull(runner.RunTestClassesAsync_CollectionFixtureMappings);33		var fixtureUnderTest = runner.RunTestClassesAsync_CollectionFixtureMappings.Values.OfType<FixtureUnderTest>().Single();34		Assert.True(fixtureUnderTest.Disposed);35	}36	[Fact]37	public static async void DisposeAndAsyncDisposableShouldBeCalledInTheRightOrder()38	{39		var collection = new TestCollection(Mocks.TestAssembly(), Reflector.Wrap(typeof(CollectionForFixtureAsyncDisposableUnderTest)), "Mock Test Collection");40		var testCase = TestData.XunitTestCase<XunitTestCollectionRunnerTests>("DisposeAndAsyncDisposableShouldBeCalledInTheRightOrder", collection);41		var runner = TestableXunitTestCollectionRunner.Create(testCase);42		var runnerSessionTask = runner.RunAsync();43		await Task.Delay(500);44		Assert.NotNull(runner.RunTestClassesAsync_CollectionFixtureMappings);45		var fixtureUnderTest = runner.RunTestClassesAsync_CollectionFixtureMappings.Values.OfType<FixtureAsyncDisposableUnderTest>().Single();46		Assert.True(fixtureUnderTest.DisposeAsyncCalled);47		Assert.False(fixtureUnderTest.Disposed);48		fixtureUnderTest.DisposeAsyncSignaler.SetResult(true);49		await runnerSessionTask;50		Assert.True(fixtureUnderTest.Disposed);51	}52	class CollectionForFixtureAsyncDisposableUnderTest : ICollectionFixture<FixtureAsyncDisposableUnderTest> { }53	class FixtureAsyncDisposableUnderTest : IAsyncDisposable, IDisposable54	{55		public bool Disposed;56		public bool DisposeAsyncCalled;57		public TaskCompletionSource<bool> DisposeAsyncSignaler = new();58		public void Dispose()59		{60			Disposed = true;61		}62		public async ValueTask DisposeAsync()63		{64			DisposeAsyncCalled = true;65			await DisposeAsyncSignaler.Task;66		}67	}68	[Fact]69	public static async void MultiplePublicConstructorsOnCollectionFixture_ReturnsError()70	{71		var collection = new TestCollection(Mocks.TestAssembly(), Reflector.Wrap(typeof(CollectionsWithMultiCtorCollectionFixture)), "Mock Test Collection");72		var testCase = TestData.XunitTestCase<XunitTestCollectionRunnerTests>("CreatesFixtures", collection);73		var runner = TestableXunitTestCollectionRunner.Create(testCase);74		await runner.RunAsync();75		var ex = Assert.IsType<TestClassException>(runner.RunTestClassAsync_AggregatorResult);76		Assert.Equal("Collection fixture type 'XunitTestCollectionRunnerTests+CollectionFixtureWithMultipleConstructors' may only define a single public constructor.", ex.Message);77	}78	class CollectionFixtureWithMultipleConstructors79	{80		public CollectionFixtureWithMultipleConstructors() { }81		public CollectionFixtureWithMultipleConstructors(int unused) { }82	}83	class CollectionsWithMultiCtorCollectionFixture : ICollectionFixture<CollectionFixtureWithMultipleConstructors> { }84	[Fact]85	public static async void UnresolvedConstructorParameterOnCollectionFixture_ReturnsError()86	{87		var collection = new TestCollection(Mocks.TestAssembly(), Reflector.Wrap(typeof(CollectionWithCollectionFixtureWithDependency)), "Mock Test Collection");88		var testCase = TestData.XunitTestCase<XunitTestCollectionRunnerTests>("CreatesFixtures", collection);89		var runner = TestableXunitTestCollectionRunner.Create(testCase);90		await runner.RunAsync();91		var ex = Assert.IsType<TestClassException>(runner.RunTestClassAsync_AggregatorResult);92		Assert.Equal("Collection fixture type 'XunitTestCollectionRunnerTests+CollectionFixtureWithCollectionFixtureDependency' had one or more unresolved constructor arguments: DependentCollectionFixture collectionFixture", ex.Message);93	}94	class DependentCollectionFixture { }95	class CollectionFixtureWithCollectionFixtureDependency96	{97		public DependentCollectionFixture CollectionFixture;98		public CollectionFixtureWithCollectionFixtureDependency(DependentCollectionFixture collectionFixture)99		{100			CollectionFixture = collectionFixture;101		}102	}103	class CollectionWithCollectionFixtureWithDependency : ICollectionFixture<CollectionFixtureWithCollectionFixtureDependency> { }104	[Fact]105	public static async void CanInjectMessageSinkIntoCollectionFixture()106	{107		var spy = SpyMessageSink.Capture();108		TestContext.Current!.DiagnosticMessageSink = spy;109		var collection = new TestCollection(Mocks.TestAssembly(), Reflector.Wrap(typeof(CollectionWithCollectionFixtureWithMessageSinkDependency)), "Mock Test Collection");110		var testCase = TestData.XunitTestCase<XunitTestCollectionRunnerTests>("CreatesFixtures", collection);111		var runner = TestableXunitTestCollectionRunner.Create(testCase);112		await runner.RunAsync();113		Assert.Null(runner.RunTestClassAsync_AggregatorResult);114		Assert.NotNull(runner.RunTestClassesAsync_CollectionFixtureMappings);115		var classFixture = runner.RunTestClassesAsync_CollectionFixtureMappings.Values.OfType<CollectionFixtureWithMessageSinkDependency>().Single();116		Assert.NotNull(classFixture.MessageSink);117		Assert.Same(spy, classFixture.MessageSink);118	}119	[Fact]120	public static async void CanLogSinkMessageFromCollectionFixture()121	{122		var spy = SpyMessageSink.Capture();123		TestContext.Current!.DiagnosticMessageSink = spy;124		var collection = new TestCollection(Mocks.TestAssembly(), Reflector.Wrap(typeof(CollectionWithCollectionFixtureWithMessageSinkDependency)), "Mock Test Collection");125		var testCase = TestData.XunitTestCase<XunitTestCollectionRunnerTests>("CreatesFixtures", collection);126		var runner = TestableXunitTestCollectionRunner.Create(testCase);127		await runner.RunAsync();128		var diagnosticMessage = Assert.Single(spy.Messages.Cast<_DiagnosticMessage>());129		Assert.Equal("CollectionFixtureWithMessageSinkDependency constructor message", diagnosticMessage.Message);130	}131	class CollectionFixtureWithMessageSinkDependency132	{133		public _IMessageSink MessageSink;134		public CollectionFixtureWithMessageSinkDependency(_IMessageSink messageSink)135		{136			MessageSink = messageSink;137			MessageSink.OnMessage(new _DiagnosticMessage { Message = "CollectionFixtureWithMessageSinkDependency constructor message" });138		}139	}140	class CollectionWithCollectionFixtureWithMessageSinkDependency : ICollectionFixture<CollectionFixtureWithMessageSinkDependency> { }141	public class TestCaseOrderer142	{143		[Fact]144		public static async void UsesCustomTestOrderer()145		{146			var collection = new TestCollection(Mocks.TestAssembly(), Reflector.Wrap(typeof(CollectionUnderTest)), "Mock Test Collection");147			var testCase = TestData.XunitTestCase<XunitTestCollectionRunnerTests>("DisposesFixtures", collection);148			var runner = TestableXunitTestCollectionRunner.Create(testCase);149			await runner.RunAsync();150			Assert.IsType<CustomTestCaseOrderer>(runner.RunTestClassesAsync_TestCaseOrderer);151		}152		[Fact]153		public static async void SettingUnknownTestCaseOrderLogsDiagnosticMessage()154		{155			var spy = SpyMessageSink.Capture();156			TestContext.Current!.DiagnosticMessageSink = spy;157			var collection = new TestCollection(Mocks.TestAssembly(), Reflector.Wrap(typeof(CollectionWithUnknownTestCaseOrderer)), "TestCollectionDisplayName");158			var testCase = TestData.XunitTestCase<XunitTestCollectionRunnerTests>("DisposesFixtures", collection);159			var runner = TestableXunitTestCollectionRunner.Create(testCase);160			await runner.RunAsync();161			Assert.IsType<MockTestCaseOrderer>(runner.RunTestClassesAsync_TestCaseOrderer);162			var diagnosticMessage = Assert.Single(spy.Messages.Cast<_DiagnosticMessage>());163			Assert.Equal("Could not find type 'UnknownType' in UnknownAssembly for collection-level test case orderer on test collection 'TestCollectionDisplayName'", diagnosticMessage.Message);164		}165		[TestCaseOrderer("UnknownType", "UnknownAssembly")]166		class CollectionWithUnknownTestCaseOrderer { }167		[Fact]168		public static async void SettingTestCaseOrdererWithThrowingConstructorLogsDiagnosticMessage()169		{170			var spy = SpyMessageSink.Capture();171			TestContext.Current!.DiagnosticMessageSink = spy;172			var collection = new TestCollection(Mocks.TestAssembly(), Reflector.Wrap(typeof(CollectionWithCtorThrowingTestCaseOrderer)), "TestCollectionDisplayName");173			var testCase = TestData.XunitTestCase<XunitTestCollectionRunnerTests>("DisposesFixtures", collection);174			var runner = TestableXunitTestCollectionRunner.Create(testCase);175			await runner.RunAsync();176			Assert.IsType<MockTestCaseOrderer>(runner.RunTestClassesAsync_TestCaseOrderer);177			var diagnosticMessage = Assert.Single(spy.Messages.Cast<_DiagnosticMessage>());178			Assert.StartsWith("Collection-level test case orderer 'XunitTestCollectionRunnerTests+TestCaseOrderer+MyCtorThrowingTestCaseOrderer' for test collection 'TestCollectionDisplayName' threw 'System.DivideByZeroException' during construction: Attempted to divide by zero.", diagnosticMessage.Message);179		}180		[TestCaseOrderer(typeof(MyCtorThrowingTestCaseOrderer))]181		class CollectionWithCtorThrowingTestCaseOrderer { }182		class MyCtorThrowingTestCaseOrderer : ITestCaseOrderer183		{184			public MyCtorThrowingTestCaseOrderer()185			{186				throw new DivideByZeroException();187			}188			public IReadOnlyCollection<TTestCase> OrderTestCases<TTestCase>(IReadOnlyCollection<TTestCase> testCases)189				where TTestCase : notnull, _ITestCase190			{191				return Array.Empty<TTestCase>();192			}193		}194	}195	class FixtureUnderTest : IDisposable196	{197		public bool Disposed;198		public void Dispose()199		{200			Disposed = true;201		}202	}203	[TestCaseOrderer(typeof(CustomTestCaseOrderer))]204	class CollectionUnderTest : ICollectionFixture<FixtureUnderTest>, ICollectionFixture<object> { }205	class CustomTestCaseOrderer : ITestCaseOrderer206	{207		public IReadOnlyCollection<TTestCase> OrderTestCases<TTestCase>(IReadOnlyCollection<TTestCase> testCases)208			where TTestCase : notnull, _ITestCase209		{210			return testCases;211		}212	}213	class TestableXunitTestCollectionRunner : XunitTestCollectionRunner214	{215		readonly ExceptionAggregator aggregator;216		readonly IReadOnlyDictionary<Type, object> assemblyFixtureMappings;217		readonly CancellationTokenSource cancellationTokenSource;218		readonly IMessageBus messageBus;219		readonly ITestCaseOrderer testCaseOrderer;220		readonly IReadOnlyCollection<IXunitTestCase> testCases;221		readonly _ITestCollection testCollection;222		public Exception? RunTestClassAsync_AggregatorResult;223		public Dictionary<Type, object>? RunTestClassesAsync_CollectionFixtureMappings;224		public ITestCaseOrderer? RunTestClassesAsync_TestCaseOrderer;225		TestableXunitTestCollectionRunner(226			_ITestCollection testCollection,227			IReadOnlyCollection<IXunitTestCase> testCases,228			IMessageBus messageBus,229			ITestCaseOrderer testCaseOrderer,230			ExceptionAggregator aggregator,231			CancellationTokenSource cancellationTokenSource,232			IReadOnlyDictionary<Type, object> assemblyFixtureMappings)233		{234			this.testCollection = testCollection;235			this.testCases = testCases;236			this.messageBus = messageBus;237			this.testCaseOrderer = testCaseOrderer;238			this.aggregator = aggregator;239			this.cancellationTokenSource = cancellationTokenSource;240			this.assemblyFixtureMappings = assemblyFixtureMappings;241		}242		public static TestableXunitTestCollectionRunner Create(243			IXunitTestCase testCase,244			params object[] assemblyFixtures) =>245				new(246					testCase.TestCollection,247					new[] { testCase },248					new SpyMessageBus(),249					new MockTestCaseOrderer(),250					new ExceptionAggregator(),251					new CancellationTokenSource(),252					assemblyFixtures.ToDictionary(fixture => fixture.GetType())253				);254		public ValueTask<RunSummary> RunAsync() =>255			RunAsync(new(testCollection, testCases, messageBus, testCaseOrderer, aggregator, cancellationTokenSource, assemblyFixtureMappings));256		protected override ValueTask<RunSummary> RunTestClassesAsync(XunitTestCollectionRunnerContext ctxt)257		{258			var result = base.RunTestClassesAsync(ctxt);259			RunTestClassesAsync_CollectionFixtureMappings = ctxt.CollectionFixtureMappings;260			RunTestClassesAsync_TestCaseOrderer = ctxt.TestCaseOrderer;261			return result;262		}263		protected override ValueTask<RunSummary> RunTestClassAsync(264			XunitTestCollectionRunnerContext ctxt,265			_ITestClass? testClass,266			_IReflectionTypeInfo? @class,267			IReadOnlyCollection<IXunitTestCase> testCases)268		{269			RunTestClassAsync_AggregatorResult = ctxt.Aggregator.ToException();270			return new(new RunSummary());271		}272	}273}...

TestCollectionRunnerTests.cs

Source:TestCollectionRunnerTests.cs

...6using NSubstitute;7using Xunit;8using Xunit.Sdk;9using Xunit.v3;10public class TestCollectionRunnerTests11{12	[Fact]13	public static async void Messages()14	{15		var summary = new RunSummary { Total = 4, Failed = 2, Skipped = 1, Time = 21.12m };16		var messageBus = new SpyMessageBus();17		var testCase = Mocks.TestCase<ClassUnderTest>("Passing");18		var runner = TestableTestCollectionRunner.Create(messageBus, new[] { testCase }, summary);19		var result = await runner.RunAsync();20		Assert.Equal(result.Total, summary.Total);21		Assert.Equal(result.Failed, summary.Failed);22		Assert.Equal(result.Skipped, summary.Skipped);23		Assert.Equal(result.Time, summary.Time);24		Assert.False(runner.TokenSource.IsCancellationRequested);25		Assert.Collection(26			messageBus.Messages,27			msg =>28			{29				var starting = Assert.IsAssignableFrom<_TestCollectionStarting>(msg);30				Assert.Equal("assembly-id", starting.AssemblyUniqueID);31				Assert.Null(starting.TestCollectionClass);32				Assert.Equal("Mock test collection", starting.TestCollectionDisplayName);33				Assert.Equal("collection-id", starting.TestCollectionUniqueID);34			},35			msg =>36			{37				var finished = Assert.IsAssignableFrom<_TestCollectionFinished>(msg);38				Assert.Equal("assembly-id", finished.AssemblyUniqueID);39				Assert.Equal(21.12m, finished.ExecutionTime);40				Assert.Equal("collection-id", finished.TestCollectionUniqueID);41				Assert.Equal(2, finished.TestsFailed);42				Assert.Equal(4, finished.TestsRun);43				Assert.Equal(1, finished.TestsSkipped);44			}45		);46	}47	[Fact]48	public static async void FailureInQueueOfTestCollectionStarting_DoesNotQueueTestCollectionFinished_DoesNotRunTestClasses()49	{50		var messages = new List<_MessageSinkMessage>();51		var messageBus = Substitute.For<IMessageBus>();52		messageBus53			.QueueMessage(null!)54			.ReturnsForAnyArgs(callInfo =>55			{56				var msg = callInfo.Arg<_MessageSinkMessage>();57				messages.Add(msg);58				if (msg is _TestCollectionStarting)59					throw new InvalidOperationException();60				return true;61			});62		var runner = TestableTestCollectionRunner.Create(messageBus);63		var ex = await Record.ExceptionAsync(() => runner.RunAsync());64		Assert.IsType<InvalidOperationException>(ex);65		var starting = Assert.Single(messages);66		Assert.IsAssignableFrom<_TestCollectionStarting>(starting);67		Assert.Empty(runner.ClassesRun);68	}69	[Fact]70	public static async void RunTestClassAsync_AggregatorIncludesPassedInExceptions()71	{72		var messageBus = new SpyMessageBus();73		var ex = new DivideByZeroException();74		var runner = TestableTestCollectionRunner.Create(messageBus, aggregatorSeedException: ex);75		await runner.RunAsync();76		Assert.Same(ex, runner.RunTestClassAsync_AggregatorResult);77		Assert.Empty(messageBus.Messages.OfType<_TestCollectionCleanupFailure>());78	}79	[Fact]80	public static async void FailureInAfterTestCollectionStarting_GivesErroredAggregatorToTestClassRunner_NoCleanupFailureMessage()81	{82		var messageBus = new SpyMessageBus();83		var runner = TestableTestCollectionRunner.Create(messageBus);84		var ex = new DivideByZeroException();85		runner.AfterTestCollectionStarting_Callback = aggregator => aggregator.Add(ex);86		await runner.RunAsync();87		Assert.Same(ex, runner.RunTestClassAsync_AggregatorResult);88		Assert.Empty(messageBus.Messages.OfType<_TestCollectionCleanupFailure>());89	}90	[Fact]91	public static async void FailureInBeforeTestCollectionFinished_ReportsCleanupFailure_DoesNotIncludeExceptionsFromAfterTestCollectionStarting()92	{93		var messageBus = new SpyMessageBus();94		var testCases = new[] { Mocks.TestCase<TestAssemblyRunnerTests.RunAsync>("Messages") };95		var runner = TestableTestCollectionRunner.Create(messageBus, testCases);96		var startingException = new DivideByZeroException();97		var finishedException = new InvalidOperationException();98		runner.AfterTestCollectionStarting_Callback = aggregator => aggregator.Add(startingException);99		runner.BeforeTestCollectionFinished_Callback = aggregator => aggregator.Add(finishedException);100		await runner.RunAsync();101		var cleanupFailure = Assert.Single(messageBus.Messages.OfType<_TestCollectionCleanupFailure>());102		Assert.Equal(typeof(InvalidOperationException).FullName, cleanupFailure.ExceptionTypes.Single());103	}104	[Fact]105	public static async void Cancellation_TestCollectionStarting_DoesNotCallExtensibilityCallbacks()106	{107		var messageBus = new SpyMessageBus(msg => !(msg is _TestCollectionStarting));108		var runner = TestableTestCollectionRunner.Create(messageBus);109		await runner.RunAsync();110		Assert.True(runner.TokenSource.IsCancellationRequested);111		Assert.False(runner.AfterTestCollectionStarting_Called);112		Assert.False(runner.BeforeTestCollectionFinished_Called);113	}114	[Fact]115	public static async void Cancellation_TestCollectionFinished_CallsExtensibilityCallbacks()116	{117		var messageBus = new SpyMessageBus(msg => !(msg is _TestCollectionFinished));118		var runner = TestableTestCollectionRunner.Create(messageBus);119		await runner.RunAsync();120		Assert.True(runner.TokenSource.IsCancellationRequested);121		Assert.True(runner.AfterTestCollectionStarting_Called);122		Assert.True(runner.BeforeTestCollectionFinished_Called);123	}124	[Fact]125	public static async void Cancellation_TestCollectionCleanupFailure_SetsCancellationToken()126	{127		var messageBus = new SpyMessageBus(msg => !(msg is _TestCollectionCleanupFailure));128		var runner = TestableTestCollectionRunner.Create(messageBus);129		runner.BeforeTestCollectionFinished_Callback = aggregator => aggregator.Add(new Exception());130		await runner.RunAsync();131		Assert.True(runner.TokenSource.IsCancellationRequested);132	}133	[Fact]134	public static async void TestsAreGroupedByCollection()135	{136		var passing1 = Mocks.TestCase<ClassUnderTest>("Passing");137		var other1 = Mocks.TestCase<ClassUnderTest>("Other");138		var passing2 = Mocks.TestCase<ClassUnderTest2>("Passing");139		var other2 = Mocks.TestCase<ClassUnderTest2>("Other");140		var runner = TestableTestCollectionRunner.Create(testCases: new[] { passing1, passing2, other2, other1 });141		await runner.RunAsync();142		Assert.Collection(143			runner.ClassesRun,144			tuple =>145			{146				Assert.Equal("TestCollectionRunnerTests+ClassUnderTest", tuple.Item1?.Name);147				Assert.Collection(tuple.Item2,148					testCase => Assert.Same(passing1, testCase),149					testCase => Assert.Same(other1, testCase)150				);151			},152			tuple =>153			{154				Assert.Equal("TestCollectionRunnerTests+ClassUnderTest2", tuple.Item1?.Name);155				Assert.Collection(tuple.Item2,156					testCase => Assert.Same(passing2, testCase),157					testCase => Assert.Same(other2, testCase)158				);159			}160		);161	}162	[Fact]163	public static async void SignalingCancellationStopsRunningClasses()164	{165		var passing1 = Mocks.TestCase<ClassUnderTest>("Passing");166		var passing2 = Mocks.TestCase<ClassUnderTest2>("Passing");167		var runner = TestableTestCollectionRunner.Create(testCases: new[] { passing1, passing2 }, cancelInRunTestClassAsync: true);168		await runner.RunAsync();169		var tuple = Assert.Single(runner.ClassesRun);170		Assert.Equal("TestCollectionRunnerTests+ClassUnderTest", tuple.Item1?.Name);171	}172	[Fact]173	public static async void TestContextInspection()174	{175		var runner = TestableTestCollectionRunner.Create();176		await runner.RunAsync();177		Assert.NotNull(runner.AfterTestCollectionStarting_Context);178		Assert.Equal(TestEngineStatus.Running, runner.AfterTestCollectionStarting_Context.TestAssemblyStatus);179		Assert.Equal(TestEngineStatus.Initializing, runner.AfterTestCollectionStarting_Context.TestCollectionStatus);180		Assert.Equal(TestPipelineStage.TestCollectionExecution, runner.AfterTestCollectionStarting_Context.PipelineStage);181		Assert.Null(runner.AfterTestCollectionStarting_Context.TestClassStatus);182		Assert.Null(runner.AfterTestCollectionStarting_Context.TestMethodStatus);183		Assert.Null(runner.AfterTestCollectionStarting_Context.TestCaseStatus);184		Assert.Null(runner.AfterTestCollectionStarting_Context.TestStatus);185		Assert.Same(runner.TestCollection, runner.AfterTestCollectionStarting_Context.TestCollection);186		Assert.NotNull(runner.RunTestClassAsync_Context);187		Assert.Equal(TestEngineStatus.Running, runner.RunTestClassAsync_Context.TestAssemblyStatus);188		Assert.Equal(TestEngineStatus.Running, runner.RunTestClassAsync_Context.TestCollectionStatus);189		Assert.Null(runner.RunTestClassAsync_Context.TestClassStatus);190		Assert.Null(runner.RunTestClassAsync_Context.TestMethodStatus);191		Assert.Null(runner.RunTestClassAsync_Context.TestCaseStatus);192		Assert.Null(runner.RunTestClassAsync_Context.TestStatus);193		Assert.Same(runner.TestCollection, runner.RunTestClassAsync_Context.TestCollection);194		Assert.NotNull(runner.BeforeTestCollectionFinished_Context);195		Assert.Equal(TestEngineStatus.Running, runner.BeforeTestCollectionFinished_Context.TestAssemblyStatus);196		Assert.Equal(TestEngineStatus.CleaningUp, runner.BeforeTestCollectionFinished_Context.TestCollectionStatus);197		Assert.Null(runner.BeforeTestCollectionFinished_Context.TestClassStatus);198		Assert.Null(runner.BeforeTestCollectionFinished_Context.TestMethodStatus);199		Assert.Null(runner.BeforeTestCollectionFinished_Context.TestCaseStatus);200		Assert.Null(runner.BeforeTestCollectionFinished_Context.TestStatus);201		Assert.Same(runner.TestCollection, runner.BeforeTestCollectionFinished_Context.TestCollection);202	}203	class ClassUnderTest204	{205		[Fact]206		public void Passing() { }207		[Fact]208		public void Other() { }209	}210	class ClassUnderTest2 : ClassUnderTest { }211	class TestableTestCollectionRunner : TestCollectionRunner<TestCollectionRunnerContext<_ITestCase>, _ITestCase>212	{213		readonly ExceptionAggregator aggregator;214		readonly bool cancelInRunTestClassAsync;215		readonly IMessageBus messageBus;216		readonly RunSummary result;217		readonly ITestCaseOrderer testCaseOrderer;218		readonly IReadOnlyCollection<_ITestCase> testCases;219		public readonly List<Tuple<_IReflectionTypeInfo?, IReadOnlyCollection<_ITestCase>>> ClassesRun = new();220		public Action<ExceptionAggregator> AfterTestCollectionStarting_Callback = _ => { };221		public bool AfterTestCollectionStarting_Called;222		public TestContext? AfterTestCollectionStarting_Context;223		public Action<ExceptionAggregator> BeforeTestCollectionFinished_Callback = _ => { };224		public bool BeforeTestCollectionFinished_Called;225		public TestContext? BeforeTestCollectionFinished_Context;226		public Exception? RunTestClassAsync_AggregatorResult;227		public TestContext? RunTestClassAsync_Context;228		public readonly _ITestCollection TestCollection;229		public readonly CancellationTokenSource TokenSource;230		TestableTestCollectionRunner(231			_ITestCollection testCollection,232			IReadOnlyCollection<_ITestCase> testCases,233			IMessageBus messageBus,234			ITestCaseOrderer testCaseOrderer,235			ExceptionAggregator aggregator,236			CancellationTokenSource cancellationTokenSource,237			RunSummary result,238			bool cancelInRunTestClassAsync)239		{240			TestCollection = testCollection;241			this.testCases = testCases;242			this.messageBus = messageBus;243			this.testCaseOrderer = testCaseOrderer;244			this.aggregator = aggregator;245			TokenSource = cancellationTokenSource;246			this.result = result;247			this.cancelInRunTestClassAsync = cancelInRunTestClassAsync;248		}249		public static TestableTestCollectionRunner Create(250			IMessageBus? messageBus = null,251			_ITestCase[]? testCases = null,252			RunSummary? result = null,253			Exception? aggregatorSeedException = null,254			bool cancelInRunTestClassAsync = false)255		{256			if (testCases == null)257				testCases = new[] { Mocks.TestCase<ClassUnderTest>("Passing") };258			var aggregator = new ExceptionAggregator();259			if (aggregatorSeedException != null)260				aggregator.Add(aggregatorSeedException);261			return new TestableTestCollectionRunner(262				testCases.First().TestCollection,263				testCases,264				messageBus ?? new SpyMessageBus(),265				new MockTestCaseOrderer(),266				aggregator,267				new CancellationTokenSource(),268				result ?? new RunSummary(),269				cancelInRunTestClassAsync270			);271		}272		protected override ValueTask AfterTestCollectionStartingAsync(TestCollectionRunnerContext<_ITestCase> ctxt)273		{274			AfterTestCollectionStarting_Called = true;275			AfterTestCollectionStarting_Context = TestContext.Current;276			AfterTestCollectionStarting_Callback(ctxt.Aggregator);277			return default;278		}279		protected override ValueTask BeforeTestCollectionFinishedAsync(TestCollectionRunnerContext<_ITestCase> ctxt)280		{281			BeforeTestCollectionFinished_Called = true;282			BeforeTestCollectionFinished_Context = TestContext.Current;283			BeforeTestCollectionFinished_Callback(ctxt.Aggregator);284			return default;285		}286		public ValueTask<RunSummary> RunAsync() =>287			RunAsync(new(TestCollection, testCases, messageBus, testCaseOrderer, aggregator, TokenSource));288		protected override ValueTask<RunSummary> RunTestClassAsync(289			TestCollectionRunnerContext<_ITestCase> ctxt,290			_ITestClass? testClass,291			_IReflectionTypeInfo? @class,292			IReadOnlyCollection<_ITestCase> testCases)293		{294			if (cancelInRunTestClassAsync)295				ctxt.CancellationTokenSource.Cancel();296			RunTestClassAsync_AggregatorResult = ctxt.Aggregator.ToException();297			RunTestClassAsync_Context = TestContext.Current;298			ClassesRun.Add(Tuple.Create(@class, testCases));299			return new(result);300		}301	}302}...

XunitTestFrameworkDiscovererTests.cs

Source:XunitTestFrameworkDiscovererTests.cs

...24			[Fact]25			public static void TestMethod() { }26		}27		[Fact]28		public static async void DefaultTestCollection()29		{30			var discoverer = TestableXunitTestFrameworkDiscoverer.Create();31			var type = Reflector.Wrap(typeof(ClassWithNoCollection));32			var testClass = await discoverer.CreateTestClass(type);33			Assert.NotNull(testClass.TestCollection);34			Assert.Equal("Test collection for XunitTestFrameworkDiscovererTests+CreateTestClass+ClassWithNoCollection", testClass.TestCollection.DisplayName);35			Assert.Null(testClass.TestCollection.CollectionDefinition);36		}37		[Collection("This a collection without declaration")]38		class ClassWithUndeclaredCollection39		{40			[Fact]41			public static void TestMethod() { }42		}43		[Fact]44		public static async void UndeclaredTestCollection()45		{46			var discoverer = TestableXunitTestFrameworkDiscoverer.Create();47			var type = Reflector.Wrap(typeof(ClassWithUndeclaredCollection));48			var testClass = await discoverer.CreateTestClass(type);49			Assert.NotNull(testClass.TestCollection);50			Assert.Equal("This a collection without declaration", testClass.TestCollection.DisplayName);51			Assert.Null(testClass.TestCollection.CollectionDefinition);52		}53		[CollectionDefinition("This a defined collection")]54		public class DeclaredCollection { }55		[Collection("This a defined collection")]56		class ClassWithDefinedCollection57		{58			[Fact]59			public static void TestMethod() { }60		}61		[Fact]62		public static async void DefinedTestCollection()63		{64			var type = Reflector.Wrap(typeof(ClassWithDefinedCollection));65			var discoverer = TestableXunitTestFrameworkDiscoverer.Create(type.Assembly);66			var testClass = await discoverer.CreateTestClass(type);67			Assert.NotNull(testClass.TestCollection);68			Assert.Equal("This a defined collection", testClass.TestCollection.DisplayName);69			Assert.NotNull(testClass.TestCollection.CollectionDefinition);70			Assert.Equal("XunitTestFrameworkDiscovererTests+CreateTestClass+DeclaredCollection", testClass.TestCollection.CollectionDefinition.Name);71		}72	}73	public class FindTestsForType74	{75		[Fact]76		public static async ValueTask RequestsPublicAndPrivateMethodsFromType()77		{78			var typeInfo = Mocks.TypeInfo();79			var testClass = Mocks.TestClass(typeInfo);80			var discoverer = TestableXunitTestFrameworkDiscoverer.Create();81			await discoverer.FindTestsForType(testClass);82			typeInfo.Received(1).GetMethods(includePrivateMethods: true);83		}84		[Fact]85		public static async ValueTask TestMethodWithTooManyFactAttributes_ReturnsExecutionErrorTestCase()86		{87			var testClass = Mocks.TestClass<ClassWithTooManyFactAttributesOnTestMethod>();88			var discoverer = TestableXunitTestFrameworkDiscoverer.Create();89			await discoverer.FindTestsForType(testClass);90			var testCase = Assert.Single(discoverer.FindTestsForType_TestCases);91			var errorTestCase = Assert.IsType<ExecutionErrorTestCase>(testCase);92			Assert.Equal($"Test method '{typeof(ClassWithTooManyFactAttributesOnTestMethod).FullName}.{nameof(ClassWithTooManyFactAttributesOnTestMethod.TestMethod)}' has multiple [Fact]-derived attributes", errorTestCase.ErrorMessage);93		}94		class ClassWithTooManyFactAttributesOnTestMethod95		{96			[Fact]97			[Theory]98			public void TestMethod() { }99		}100		[Fact]101		public static async ValueTask DoesNotDiscoverNonFactDecoratedTestMethod()102		{103			var testClass = Mocks.TestClass<ClassWithNoTests>();104			var discoverer = TestableXunitTestFrameworkDiscoverer.Create();105			await discoverer.FindTestsForType(testClass);106			Assert.Empty(discoverer.FindTestsForType_TestCases);107		}108		class ClassWithNoTests109		{110			public void TestMethod() { }111		}112		[Fact]113		public static async ValueTask DiscoversFactDecoratedTestMethod()114		{115			var testClass = Mocks.TestClass<ClassWithOneTest>();116			var discoverer = TestableXunitTestFrameworkDiscoverer.Create();117			await discoverer.FindTestsForType(testClass);118			var testCase = Assert.Single(discoverer.FindTestsForType_TestCases);119			Assert.IsType<XunitTestCase>(testCase);120			Assert.Equal($"{typeof(ClassWithOneTest).FullName}.{nameof(ClassWithOneTest.TestMethod)}", testCase.TestCaseDisplayName);121		}122		class ClassWithOneTest123		{124			[Fact]125			public void TestMethod() { }126		}127		[Fact]128		public static async void Theory_WithPreEnumeration_ReturnsOneTestCasePerDataRecord()129		{130			var testClass = Mocks.TestClass<TheoryWithInlineData>();131			var discoverer = TestableXunitTestFrameworkDiscoverer.Create();132			var discoveryOptions = _TestFrameworkOptions.ForDiscovery(preEnumerateTheories: true);133			await discoverer.FindTestsForType(testClass, discoveryOptions);134			Assert.Collection(135				discoverer.FindTestsForType_TestCases.Select(t => t.TestCaseDisplayName).OrderBy(x => x),136				displayName => Assert.Equal($"{typeof(TheoryWithInlineData).FullName}.{nameof(TheoryWithInlineData.TheoryMethod)}(value: \"Hello world\")", displayName),137				displayName => Assert.Equal($"{typeof(TheoryWithInlineData).FullName}.{nameof(TheoryWithInlineData.TheoryMethod)}(value: 42)", displayName)138			);139		}140		[Fact]141		public static async void Theory_WithoutPreEnumeration_ReturnsOneTestCase()142		{143			var testClass = Mocks.TestClass<TheoryWithInlineData>();144			var discoverer = TestableXunitTestFrameworkDiscoverer.Create();145			var discoveryOptions = _TestFrameworkOptions.ForDiscovery(preEnumerateTheories: false);146			await discoverer.FindTestsForType(testClass, discoveryOptions);147			var testCase = Assert.Single(discoverer.FindTestsForType_TestCases);148			Assert.Equal($"{typeof(TheoryWithInlineData).FullName}.{nameof(TheoryWithInlineData.TheoryMethod)}", testCase.TestCaseDisplayName);149		}150		class TheoryWithInlineData151		{152			[Theory]153			[InlineData("Hello world")]154			[InlineData(42)]155			public static void TheoryMethod(object value) { }156		}157		[Fact]158		public static async void AssemblyWithMultiLevelHierarchyWithFactOverridenInNonImmediateDerivedClass_ReturnsOneTestCase()159		{160			var testClass = Mocks.TestClass<Child>();161			var discoverer = TestableXunitTestFrameworkDiscoverer.Create();162			await discoverer.FindTestsForType(testClass);163			var testCase = Assert.Single(discoverer.FindTestsForType_TestCases);164			Assert.Equal($"{typeof(Child).FullName}.{nameof(GrandParent.FactOverridenInNonImmediateDerivedClass)}", testCase.TestCaseDisplayName);165		}166		public abstract class GrandParent167		{168			[Fact]169			public virtual void FactOverridenInNonImmediateDerivedClass()170			{171				Assert.True(true);172			}173		}174		public abstract class Parent : GrandParent { }175		public class Child : Parent176		{177			public override void FactOverridenInNonImmediateDerivedClass()178			{179				base.FactOverridenInNonImmediateDerivedClass();180				Assert.False(false);181			}182		}183	}184	public static class TestCollectionFactory185	{186		[Fact]187		public static void DefaultTestCollectionFactory()188		{189			var discoverer = TestableXunitTestFrameworkDiscoverer.Create();190			Assert.IsType<CollectionPerClassTestCollectionFactory>(discoverer.TestCollectionFactory);191		}192		[Theory(DisableDiscoveryEnumeration = true)]193		[InlineData(CollectionBehavior.CollectionPerAssembly, typeof(CollectionPerAssemblyTestCollectionFactory))]194		[InlineData(CollectionBehavior.CollectionPerClass, typeof(CollectionPerClassTestCollectionFactory))]195		public static void AssemblyAttributeOverride(196			CollectionBehavior behavior,197			Type expectedFactoryType)198		{199			var behaviorAttribute = Mocks.CollectionBehaviorAttribute(behavior);200			var assembly = Mocks.AssemblyInfo(attributes: new[] { behaviorAttribute });201			var discoverer = TestableXunitTestFrameworkDiscoverer.Create(assembly);202			Assert.IsType(expectedFactoryType, discoverer.TestCollectionFactory);203		}204		[Fact]205		public static void ValidCustomFactory()206		{207			var behaviorAttribute = Mocks.CollectionBehaviorAttribute<CustomTestCollectionFactory>();208			var assembly = Mocks.AssemblyInfo(attributes: new[] { behaviorAttribute });209			var discoverer = TestableXunitTestFrameworkDiscoverer.Create(assembly);210			Assert.IsType<CustomTestCollectionFactory>(discoverer.TestCollectionFactory);211		}212		[Fact]213		public static void InvalidCustomFactoryFallsBackToDefault()214		{215			var spyMessageSink = SpyMessageSink.Capture();216			TestContext.Current!.DiagnosticMessageSink = spyMessageSink;217			var behaviorAttribute = Mocks.CollectionBehaviorAttribute<object>();218			var assembly = Mocks.AssemblyInfo(attributes: new[] { behaviorAttribute });219			var discoverer = TestableXunitTestFrameworkDiscoverer.Create(assembly);220			Assert.IsType<CollectionPerClassTestCollectionFactory>(discoverer.TestCollectionFactory);221			var message = Assert.Single(spyMessageSink.Messages);222			var diagMessage = Assert.IsType<_DiagnosticMessage>(message);223			Assert.Equal("Test collection factory type 'System.Object' does not implement IXunitTestCollectionFactory", diagMessage.Message);224		}225	}226	public static class TestFrameworkDisplayName227	{228		[Fact]229		public static void Defaults()230		{231			var discoverer = TestableXunitTestFrameworkDiscoverer.Create();232			Assert.Matches(@"xUnit.net v3 \d+\.\d+\.\d+(-pre\.\d+(-dev)?(\+[0-9a-f]+)?)? \[collection-per-class, parallel\]", discoverer.TestFrameworkDisplayName);233		}234		[Fact]235		public static void CollectionPerAssembly()236		{237			var behaviorAttribute = Mocks.CollectionBehaviorAttribute(CollectionBehavior.CollectionPerAssembly);238			var assembly = Mocks.AssemblyInfo(attributes: new[] { behaviorAttribute });239			var discoverer = TestableXunitTestFrameworkDiscoverer.Create(assembly);240			Assert.Matches(@"xUnit.net v3 \d+\.\d+\.\d+(-pre\.\d+(-dev)?(\+[0-9a-f]+)?)? \[collection-per-assembly, parallel\]", discoverer.TestFrameworkDisplayName);241		}242		[Fact]243		public static void CustomCollectionFactory()244		{245			var behaviorAttribute = Mocks.CollectionBehaviorAttribute<CustomTestCollectionFactory>();246			var assembly = Mocks.AssemblyInfo(attributes: new[] { behaviorAttribute });247			var discoverer = TestableXunitTestFrameworkDiscoverer.Create(assembly);248			Assert.Matches(@"xUnit.net v3 \d+\.\d+\.\d+(-pre\.\d+(-dev)?(\+[0-9a-f]+)?)? \[my-custom-test-collection-factory, parallel\]", discoverer.TestFrameworkDisplayName);249		}250		[Fact]251		public static void NonParallel()252		{253			var behaviorAttribute = Mocks.CollectionBehaviorAttribute(disableTestParallelization: true);254			var assembly = Mocks.AssemblyInfo(attributes: new[] { behaviorAttribute });255			var discoverer = TestableXunitTestFrameworkDiscoverer.Create(assembly);256			Assert.Matches(@"xUnit.net v3 \d+\.\d+\.\d+(-pre\.\d+(-dev)?(\+[0-9a-f]+)?)? \[collection-per-class, non-parallel\]", discoverer.TestFrameworkDisplayName);257		}258	}259	class ClassWithSingleTest260	{261		[Fact]262		public static void TestMethod() { }263	}264	class CustomTestCollectionFactory : IXunitTestCollectionFactory265	{266		public CustomTestCollectionFactory(_ITestAssembly testAssembly)267		{ }268		public string DisplayName => "my-custom-test-collection-factory";269		public _ITestCollection Get(_ITypeInfo testClass) => throw new NotImplementedException();270	}271	class TestableXunitTestFrameworkDiscoverer : XunitTestFrameworkDiscoverer272	{273		public List<_ITestCaseMetadata> FindTestsForType_TestCases = new();274		TestableXunitTestFrameworkDiscoverer(275			_IAssemblyInfo assemblyInfo,276			IXunitTestCollectionFactory? collectionFactory)277				: base(assemblyInfo, configFileName: null, collectionFactory)278		{279			TestAssembly = Mocks.TestAssembly(assemblyInfo.AssemblyPath, uniqueID: "asm-id");280		}281		public new _IAssemblyInfo AssemblyInfo => base.AssemblyInfo;282		public override _ITestAssembly TestAssembly { get; }283		public new ValueTask<_ITestClass> CreateTestClass(_ITypeInfo @class) =>284			base.CreateTestClass(@class);285		public ValueTask<bool> FindTestsForType(286			_ITestClass testClass,287			_ITestFrameworkDiscoveryOptions? discoveryOptions = null) =>288				base.FindTestsForType(289					testClass,290					discoveryOptions ?? _TestFrameworkOptions.ForDiscovery(preEnumerateTheories: true),291					testCase =>292					{293						FindTestsForType_TestCases.Add(testCase);294						return new(true);295					}296				);297		protected sealed override bool IsValidTestClass(_ITypeInfo type) =>298			base.IsValidTestClass(type);299		public static TestableXunitTestFrameworkDiscoverer Create(300			_IAssemblyInfo? assembly = null,301			IXunitTestCollectionFactory? collectionFactory = null) =>302				new(assembly ?? Mocks.AssemblyInfo(), collectionFactory);303	}304}...

XunitTestCaseTests.cs

Source:XunitTestCaseTests.cs

...149		[MemberData(nameof(CustomAttributeTestCases))]150		public void ReturnsCorrectCustomAttributes(Type classType, IEnumerable<string> expectedTraits)151		{152			var testAssembly = new TestAssembly(new ReflectionAssemblyInfo(classType.Assembly));153			var testCollection = new TestCollection(testAssembly, null, "Trait inheritance tests");154			var @class = new ReflectionTypeInfo(classType);155			var testClass = new TestClass(testCollection, @class);156			var methodInfo = new ReflectionMethodInfo(classType.GetMethod("TraitsTest")!);157			var testMethod = new TestMethod(testClass, methodInfo);158			var testCase = new TestableXunitTestCase(testMethod);159			var testTraits = testCase.Traits["Test"];160			Assert.NotNull(testTraits);161			foreach (var expectedTrait in expectedTraits)162				Assert.Contains(expectedTrait, testTraits);163		}164		class BaseClassWithoutTraits165		{ }166		[Trait("Test", "BaseOne")]167		class BaseClassWithSingleTrait...

Mocks.TestCases.cs

Source:Mocks.TestCases.cs

...84			testMethod ??= TestMethod();85			displayName ??= $"{testMethod.TestClass.Class.Name}.{testMethod.Method.Name}";86			traits ??= GetTraits(testMethod.Method);87			uniqueID ??= "case-id";88			var testCollection = testMethod.TestClass.TestCollection;89			var testClass = testMethod.TestClass;90			var result = Substitute.For<_ITestCase, InterfaceProxy<_ITestCase>>();91			result.TestCaseDisplayName.Returns(displayName);92			result.SkipReason.Returns(skipReason);93			result.SourceFilePath.Returns(fileName);94			result.SourceLineNumber.Returns(lineNumber);95			result.TestCollection.Returns(testCollection);96			result.TestClass.Returns(testClass);97			result.TestMethod.Returns(testMethod);98			result.Traits.Returns(traits);99			result.UniqueID.Returns(uniqueID);100			return result;101		}102		public static _ITestClass TestClass<TClassUnderTest>(103			_ITestCollection? collection = null,104			string? uniqueID = null) =>105				TestClass(106					TypeInfo<TClassUnderTest>(),107					collection,108					uniqueID109				);110		public static _ITestClass TestClass(111			string? typeName,112			_IMethodInfo[]? methods = null,113			_IReflectionAttributeInfo[]? attributes = null,114			_ITypeInfo? baseType = null,115			_ITestCollection? collection = null,116			string? uniqueID = null) =>117				TestClass(TypeInfo(typeName, methods, attributes, baseType), collection, uniqueID);118		public static _ITestClass TestClass(119			_ITypeInfo? typeInfo = null,120			_ITestCollection? collection = null,121			string? uniqueID = null)122		{123			typeInfo ??= TypeInfo();124			collection ??= TestCollection();125			uniqueID ??= "class-id";126			var result = Substitute.For<_ITestClass, InterfaceProxy<_ITestClass>>();127			result.Class.Returns(typeInfo);128			result.TestCollection.Returns(collection);129			result.UniqueID.Returns(uniqueID);130			return result;131		}132		public static _ITestCollection TestCollection(133			Assembly assembly,134			_ITypeInfo? definition = null,135			string? displayName = null,136			string? uniqueID = null) =>137				TestCollection(TestAssembly(assembly), definition, displayName, uniqueID);138		public static _ITestCollection TestCollection(139			_ITestAssembly? assembly = null,140			_ITypeInfo? definition = null,141			string? displayName = null,142			string? uniqueID = null)143		{144			assembly ??= TestAssembly();145			displayName ??= "Mock test collection";146			uniqueID ??= "collection-id";147			var result = Substitute.For<_ITestCollection, InterfaceProxy<_ITestCollection>>();148			result.CollectionDefinition.Returns(definition);149			result.DisplayName.Returns(displayName);150			result.TestAssembly.Returns(assembly);151			result.UniqueID.Returns(uniqueID);152			return result;153		}154		public static _ITestMethod TestMethod(155			string? typeName = null,156			string? methodName = null,157			string? displayName = null,158			string? skip = null,159			int timeout = 0,160			_IParameterInfo[]? parameters = null,161			_IReflectionAttributeInfo[]? classAttributes = null,162			_IReflectionAttributeInfo[]? methodAttributes = null,163			_ITestCollection? collection = null,164			string? uniqueID = null)165		{166			parameters ??= EmptyParameterInfos;167			classAttributes ??= EmptyAttributeInfos;168			methodAttributes ??= EmptyAttributeInfos;169			// Ensure that there's a FactAttribute, or else it's not technically a test method170			var factAttribute = methodAttributes.FirstOrDefault(attr => typeof(FactAttribute).IsAssignableFrom(attr.Attribute.GetType()));171			if (factAttribute == null)172			{173				factAttribute = FactAttribute(displayName, skip, timeout);174				methodAttributes = methodAttributes.Concat(new[] { factAttribute }).ToArray();175			}176			var testClass = TestClass(typeName, attributes: classAttributes, collection: collection);177			var methodInfo = MethodInfo(methodName, methodAttributes, parameters, testClass.Class);178			return TestMethod(methodInfo, testClass, uniqueID);179		}180		public static _ITestMethod TestMethod<TClassUnderTest>(181			string methodName,182			_ITestCollection? collection = null,183			string? uniqueID = null) =>184				TestMethod(MethodInfo<TClassUnderTest>(methodName), TestClass<TClassUnderTest>(collection), uniqueID);185		public static _ITestMethod TestMethod(186			_IMethodInfo methodInfo,187			_ITestClass testClass,188			string? uniqueID = null)189		{190			uniqueID ??= "method-id";191			var result = Substitute.For<_ITestMethod, InterfaceProxy<_ITestMethod>>();192			result.Method.Returns(methodInfo);193			result.TestClass.Returns(testClass);194			result.UniqueID.Returns(uniqueID);195			return result;196		}...

XunitTestCaseRunnerBaseTests.cs

Source:XunitTestCaseRunnerBaseTests.cs

...6[assembly: XunitTestCaseRunnerBaseTests.BeforeAfterOnAssembly]7public class XunitTestCaseRunnerBaseTests8{9	[Fact]10	public static void BeforeAfterTestAttributesComeFromTestCollectionAndTestClassAndTestMethod()11	{12		var collection = Mocks.TestCollection(definition: Reflector.Wrap(typeof(BeforeAfterCollection)));13		var testCase = TestData.XunitTestCase<ClassUnderTest>("Passing", collection);14		var runner = new TestableXunitTestCaseRunnerBase();15		var result = runner.GetBeforeAfterTestAttributes(testCase);16		Assert.Collection(17			result.OrderBy(a => a.GetType().Name),18			attr => Assert.IsType<BeforeAfterOnAssembly>(attr),19			attr => Assert.IsType<BeforeAfterOnClass>(attr),20			attr => Assert.IsType<BeforeAfterOnCollection>(attr),21			attr => Assert.IsType<BeforeAfterOnMethod>(attr)22		);23	}24	[BeforeAfterOnCollection]25	class BeforeAfterCollection { }26	[BeforeAfterOnClass]...

TestCollection

Using AI Code Generation

1using Xunit;2using Xunit.v3;3{4    public void TestMethod()5    {6        var testCollection = Xunit.v3.Mocks.TestCollection("Test Collection");7    }8}9{10    {11        IAssemblyInfo Assembly { get; }12        string CollectionDefinition { get; }13        string DisplayName { get; }14        string Name { get; }15    }16}17using Xunit;18using Xunit.v3;19{20    public void TestMethod()21    {22        var testCollection = Xunit.v3.Mocks.TestCollection("Test Collection");23        var assembly = testCollection.Assembly;24        var collectionDefinition = testCollection.CollectionDefinition;25        var displayName = testCollection.DisplayName;26        var name = testCollection.Name;27    }28}29using Xunit;

TestCollection

Using AI Code Generation

1{2 {3 public void Test1()4 {5 Xunit.v3.Mocks.TestCollection("Test1");6 }7 }8}

TestCollection

Using AI Code Generation

1var mock = new Xunit.v3.Mocks();2var testCollection = mock.TestCollection("TestCollectionDisplayName");3var testMethod = mock.TestMethod("TestMethodName", "TestMethodSignature", "TestMethodClass", "TestMethodMethod");4var testClass = mock.TestClass("TestClass", "TestClassClass");5var testCase = mock.TestCase("TestCaseDisplayName", "TestCaseSkipReason", "TestCaseSourceInformation", testMethod, testClass, testCollection);6var testAssembly = mock.TestAssembly("TestAssemblyName", "TestAssemblyAssembly");7var testCollection = mock.TestCollection("TestCollectionDisplayName");8var testMethod = mock.TestMethod("TestMethodName", "TestMethodSignature", "TestMethodClass", "TestMethodMethod");9var testClass = mock.TestClass("TestClass", "TestClassClass");10var testCase = mock.TestCase("TestCaseDisplayName", "TestCaseSkipReason", "TestCaseSourceInformation", testMethod, testClass, testCollection);11var testAssembly = mock.TestAssembly("TestAssemblyName", "TestAssemblyAssembly");12var testCollection = mock.TestCollection("TestCollectionDisplayName");13var testMethod = mock.TestMethod("TestMethodName", "TestMethodSignature", "TestMethodClass", "TestMethodMethod");14var testClass = mock.TestClass("TestClass", "TestClassClass");15var testCase = mock.TestCase("TestCaseDisplayName", "TestCaseSkipReason", "TestCaseSourceInformation", testMethod, testClass, testCollection);16var testAssembly = mock.TestAssembly("TestAssemblyName", "TestAssemblyAssembly

TestCollection

Using AI Code Generation

1using Xunit.v3;2using Xunit.v3.Mocks;3using Xunit.v3.xUnitMock;4using Xunit.v3.xUnitMock.Attributes;5using Xunit.v3.xUnitMock.Interfaces;6using Xunit.v3.xUnitMock.Models;7using Xunit.v3.xUnitMock.Services;8{9    {10        public void TestCollection()11        {12            var mock = new Mock<IClassFixture<TestClass>>();13            var testClass = new TestClass();14            mock.Setup(x => x.Fixture).Returns(testClass);15            var collection = new TestCollection<TestClass>(mock.Object);16            var service = new TestCollectionService();17            service.Add(collection);18            var result = service.Get<TestClass>();19            Assert.Equal(testClass, result);20            Assert.Equal(collection, service.Get<TestClass>());21        }22    }23}

TestCollection

Using AI Code Generation

1var collection = Xunit.v3.Mocks.TestCollection("TestCollection");2var testMethod = Xunit.v3.Mocks.TestMethod("TestMethod");3var testClass = Xunit.v3.Mocks.TestClass("TestClass");4var testAssembly = Xunit.v3.Mocks.TestAssembly("TestAssembly");5var testCase = Xunit.v3.Mocks.TestCase("TestCase");6var testCollection = Xunit.v3.Mocks.TestCollection("TestCollection");7var testCollection = Xunit.v3.Mocks.TestCollection("TestCollection");8var testCollection = Xunit.v3.Mocks.TestCollection("TestCollection");9var testCollection = Xunit.v3.Mocks.TestCollection("TestCollection");10var testCollection = Xunit.v3.Mocks.TestCollection("TestCollection");11var testCollection = Xunit.v3.Mocks.TestCollection("TestCollection");12var testCollection = Xunit.v3.Mocks.TestCollection("TestCollection");13var testCollection = Xunit.v3.Mocks.TestCollection("TestCollection");

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.