private KeyValuePair <string, ITestCase> Deserialize(XunitTestFrameworkDiscoverer discoverer,
ITestFrameworkExecutor executor,
string serialization)
{
var testCase = default(ITestCase);
try
{
if (serialization.Length > 3 && serialization.StartsWith(":F:"))
{
// Format from TestCaseDescriptorFactory: ":F:{typeName}:{methodName}:{defaultMethodDisplay}"
var parts = serialization.Split(new[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length > 3)
{
var typeInfo = discoverer.AssemblyInfo.GetType(parts[1]);
var testClass = discoverer.CreateTestClass(typeInfo);
var methodInfo = testClass.Class.GetMethod(parts[2], true);
var testMethod = new TestMethod(testClass, methodInfo);
var defaultMethodDisplay = (TestMethodDisplay)int.Parse(parts[3]);
testCase = new XunitTestCase(DiagnosticMessageSink, defaultMethodDisplay, testMethod);
}
}
if (testCase == null)
{
testCase = executor.Deserialize(serialization);
}
return(new KeyValuePair <string, ITestCase>(testCase.UniqueID, testCase));
}
catch (Exception ex)
{
return(new KeyValuePair <string, ITestCase>(ex.ToString(), null));
}
}
public static void DefaultTestCollectionFactoryIsCollectionPerClass()
{
var assembly = Mocks.AssemblyInfo();
var sourceInfoProvider = Substitute.For<ISourceInformationProvider>();
var discoverer = new XunitTestFrameworkDiscoverer(assembly, sourceInfoProvider);
Assert.IsType<CollectionPerClassTestCollectionFactory>(discoverer.TestCollectionFactory);
Assert.Equal(XunitTestFrameworkDiscoverer.DisplayName + " [collection-per-class, parallel]", discoverer.TestFrameworkDisplayName);
}
protected override string GetTestFrameworkEnvironment()
{
var testCollectionFactory = XunitTestFrameworkDiscoverer.GetTestCollectionFactory(AssemblyInfo, collectionBehaviorAttribute);
return(String.Format("{0}-bit .NET {1} [{2}, {3}{4}]",
IntPtr.Size * 8,
Environment.Version,
testCollectionFactory.DisplayName,
disableParallelization ? "non-parallel" : "parallel",
maxParallelThreads > 0 ? String.Format(" (max {0} threads)", maxParallelThreads) : ""));
}
public static void IncompatibleOrInvalidTypesGetDefaultBehavior(string factoryTypeName)
{
var attr = Mocks.CollectionBehaviorAttribute(factoryTypeName, "test.xunit.execution");
var assembly = Mocks.AssemblyInfo(attributes: new[] { attr });
var sourceInfoProvider = Substitute.For<ISourceInformationProvider>();
var discoverer = new XunitTestFrameworkDiscoverer(assembly, sourceInfoProvider);
Assert.IsType<CollectionPerClassTestCollectionFactory>(discoverer.TestCollectionFactory);
Assert.Equal(XunitTestFrameworkDiscoverer.DisplayName + " [collection-per-class, parallel]", discoverer.TestFrameworkDisplayName);
}
public static void UserCanChooseFromBuiltInCollectionFactories_NonParallel(CollectionBehavior behavior, Type expectedType, string expectedDisplayText)
{
var attr = Mocks.CollectionBehaviorAttribute(behavior, disableTestParallelization: true);
var assembly = Mocks.AssemblyInfo(attributes: new[] { attr });
var sourceInfoProvider = Substitute.For<ISourceInformationProvider>();
var discoverer = new XunitTestFrameworkDiscoverer(assembly, sourceInfoProvider);
Assert.IsType(expectedType, discoverer.TestCollectionFactory);
Assert.Equal(String.Format("{0} [{1}, non-parallel]", XunitTestFrameworkDiscoverer.DisplayName, expectedDisplayText), discoverer.TestFrameworkDisplayName);
}
public void UserCanChooseFromBuiltInCollectionFactories_NonParallel()
{
var attr = Mocks.CollectionBehaviorAttribute(CollectionBehavior.CollectionPerAssembly, disableTestParallelization: true);
var assembly = Mocks.AssemblyInfo(attributes: new[] { attr });
var sourceInfoProvider = Substitute.For<ISourceInformationProvider>();
var discoverer = new XunitTestFrameworkDiscoverer(assembly, sourceInfoProvider);
Assert.IsType<CollectionPerAssemblyTestCollectionFactory>(discoverer.TestCollectionFactory);
Assert.Equal(XunitTestFrameworkDiscoverer.DisplayName + " [collection-per-assembly, non-parallel]", discoverer.TestFrameworkDisplayName);
}
/// <inheritdoc/>
public void Run(IMessageSink messageSink, ITestFrameworkOptions discoveryOptions, ITestFrameworkOptions executionOptions)
{
var discoverySink = new TestDiscoveryVisitor();
using (var discoverer = new XunitTestFrameworkDiscoverer(assemblyInfo, sourceInformationProvider))
{
discoverer.Find(false, discoverySink, discoveryOptions);
discoverySink.Finished.WaitOne();
}
Run(discoverySink.TestCases, messageSink, executionOptions);
}
public static void UserCanChooseCustomCollectionFactory()
{
var factoryType = typeof(MyTestCollectionFactory);
var attr = Mocks.CollectionBehaviorAttribute(factoryType.FullName, factoryType.Assembly.FullName);
var assembly = Mocks.AssemblyInfo(attributes: new[] { attr });
var sourceInfoProvider = Substitute.For<ISourceInformationProvider>();
var discoverer = new XunitTestFrameworkDiscoverer(assembly, sourceInfoProvider);
Assert.IsType<MyTestCollectionFactory>(discoverer.TestCollectionFactory);
Assert.Equal(XunitTestFrameworkDiscoverer.DisplayName + " [My Factory, parallel]", discoverer.TestFrameworkDisplayName);
}
public static void TheoriesAlwaysComeBackAsSingleXunitTheoryTestCase()
{
var sourceProvider = new NullSourceInformationProvider();
var assemblyInfo = Reflector.Wrap(Assembly.GetExecutingAssembly());
var discoverer = new XunitTestFrameworkDiscoverer(assemblyInfo, sourceProvider);
var visitor = new TestDiscoveryVisitor();
discoverer.Find(typeof(ClassWithTheory).FullName, false, visitor, new XunitDiscoveryOptions());
visitor.Finished.WaitOne();
var testCase = Assert.Single(visitor.TestCases);
Assert.IsType<XunitTheoryTestCase>(testCase);
var deserialized = SerializationHelper.Deserialize<ITestCase>(SerializationHelper.Serialize(testCase));
Assert.IsType<XunitTheoryTestCase>(deserialized);
}
public static void SerializedTestsInSameCollectionRemainInSameCollection()
{
var sourceProvider = new NullSourceInformationProvider();
var assemblyInfo = Reflector.Wrap(Assembly.GetExecutingAssembly());
var discoverer = new XunitTestFrameworkDiscoverer(assemblyInfo, sourceProvider);
var visitor = new TestDiscoveryVisitor();
discoverer.Find(typeof(ClassUnderTest).FullName, false, visitor, new XunitDiscoveryOptions());
visitor.Finished.WaitOne();
var first = visitor.TestCases[0];
var second = visitor.TestCases[1];
Assert.True(TestCollectionComparer.Instance.Equals(first.TestCollection, second.TestCollection));
var serializedFirst = SerializationHelper.Deserialize<ITestCase>(SerializationHelper.Serialize(first));
var serializedSecond = SerializationHelper.Deserialize<ITestCase>(SerializationHelper.Serialize(second));
Assert.NotSame(serializedFirst.TestCollection, serializedSecond.TestCollection);
Assert.True(TestCollectionComparer.Instance.Equals(serializedFirst.TestCollection, serializedSecond.TestCollection));
}
public static void TheoriesWithSerializableData_ReturnAsIndividualTestCases()
{
var sourceProvider = new NullSourceInformationProvider();
var assemblyInfo = Reflector.Wrap(Assembly.GetExecutingAssembly());
var discoverer = new XunitTestFrameworkDiscoverer(assemblyInfo, sourceProvider, SpyMessageSink.Create());
var sink = new TestDiscoverySink();
discoverer.Find(typeof(ClassWithTheory).FullName, false, sink, TestFrameworkOptions.ForDiscovery());
sink.Finished.WaitOne();
var first = sink.TestCases[0];
var second = sink.TestCases[1];
Assert.NotEqual(first.UniqueID, second.UniqueID);
Assert.True(TestCollectionComparer.Instance.Equals(first.TestMethod.TestClass.TestCollection, second.TestMethod.TestClass.TestCollection));
var serializedFirst = SerializationHelper.Deserialize<ITestCase>(SerializationHelper.Serialize(first));
var serializedSecond = SerializationHelper.Deserialize<ITestCase>(SerializationHelper.Serialize(second));
Assert.NotSame(serializedFirst.TestMethod.TestClass.TestCollection, serializedSecond.TestMethod.TestClass.TestCollection);
Assert.True(TestCollectionComparer.Instance.Equals(serializedFirst.TestMethod.TestClass.TestCollection, serializedSecond.TestMethod.TestClass.TestCollection));
}
/// <summary>
/// Initializes a new instance of the <see cref="XunitTestFrameworkExecutor"/> class.
/// </summary>
/// <param name="assemblyFileName">Path of the test assembly.</param>
public XunitTestFrameworkExecutor(string assemblyFileName)
{
this.assemblyFileName = assemblyFileName;
var assembly = Assembly.Load(AssemblyName.GetAssemblyName(assemblyFileName));
assemblyInfo = Reflector.Wrap(assembly);
var collectionBehaviorAttribute = assemblyInfo.GetCustomAttributes(typeof(CollectionBehaviorAttribute)).SingleOrDefault();
if (collectionBehaviorAttribute != null)
{
disableParallelization = collectionBehaviorAttribute.GetNamedArgument <bool>("DisableTestParallelization");
}
var testCollectionFactory = XunitTestFrameworkDiscoverer.GetTestCollectionFactory(assemblyInfo, collectionBehaviorAttribute);
displayName = String.Format("{0}-bit .NET {1} [{2}, {3}]",
IntPtr.Size * 8,
Environment.Version,
testCollectionFactory.DisplayName,
disableParallelization ? "non-parallel" : "parallel");
}
public static void TheoryWithNonSerializableData_ReturnsAsASingleTestCase()
{
var sourceProvider = new NullSourceInformationProvider();
var assemblyInfo = Reflector.Wrap(Assembly.GetExecutingAssembly());
var discoverer = new XunitTestFrameworkDiscoverer(assemblyInfo, sourceProvider, SpyMessageSink.Create());
var sink = new TestDiscoverySink();
discoverer.Find(typeof(ClassWithNonSerializableTheoryData).FullName, false, sink, TestFrameworkOptions.ForDiscovery());
sink.Finished.WaitOne();
var testCase = Assert.Single(sink.TestCases);
Assert.IsType<XunitTheoryTestCase>(testCase);
var deserialized = SerializationHelper.Deserialize<ITestCase>(SerializationHelper.Serialize(testCase));
Assert.IsType<XunitTheoryTestCase>(deserialized);
}
/// <inheritdoc/>
public ITestFrameworkDiscoverer GetDiscoverer(IAssemblyInfo assemblyInfo)
{
var discoverer = new XunitTestFrameworkDiscoverer(assemblyInfo, SourceInformationProvider);
toDispose.Add(discoverer);
return discoverer;
}
