public XunitTestFrameworkExecutorWithAssemblyFixture( AssemblyName assemblyName, ISourceInformationProvider sourceInformationProvider, IMessageSink diagnosticMessageSink) : base(assemblyName, sourceInformationProvider, diagnosticMessageSink) { }
/// <summary> /// Initializes a new instance of the <see cref="XunitTestFrameworkDiscoverer"/> class. /// </summary> /// <param name="assemblyInfo">The test assembly.</param> /// <param name="sourceProvider">The source information provider.</param> public XunitTestFrameworkDiscoverer(IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider = null) { Guard.ArgumentNotNull("assemblyInfo", assemblyInfo); this.assemblyInfo = assemblyInfo; this.sourceProvider = sourceProvider ?? new VisualStudioSourceInformationProvider(); }
/// <summary> /// Initializes a new instance of the <see cref="XunitFrontController"/> class. /// </summary> /// <param name="assemblyFileName">The test assembly.</param> /// <param name="configFileName">The test assembly configuration file.</param> /// <param name="shadowCopy">If set to <c>true</c>, runs tests in a shadow copied app domain, which allows /// <param name="shadowCopyFolder">The path on disk to use for shadow copying; if <c>null</c>, a folder /// will be automatically (randomly) generated</param> /// <param name="sourceInformationProvider">The source information provider. If <c>null</c>, uses the default (<see cref="T:Xunit.VisualStudioSourceInformationProvider"/>).</param> /// tests to be discovered and run without locking assembly files on disk.</param> /// <param name="diagnosticMessageSink">The message sink which received <see cref="IDiagnosticMessage"/> messages.</param> public XunitFrontController(string assemblyFileName, string configFileName = null, bool shadowCopy = true, string shadowCopyFolder = null, ISourceInformationProvider sourceInformationProvider = null, IMessageSink diagnosticMessageSink = null) { this.assemblyFileName = assemblyFileName; this.configFileName = configFileName; this.shadowCopy = shadowCopy; this.shadowCopyFolder = shadowCopyFolder; this.sourceInformationProvider = sourceInformationProvider; this.diagnosticMessageSink = diagnosticMessageSink ?? new NullMessageSink(); Guard.FileExists("assemblyFileName", assemblyFileName); if (this.sourceInformationProvider == null) { #if !XAMARIN && !WINDOWS_PHONE_APP && !WINDOWS_PHONE && !ASPNET50 && !ASPNETCORE50 this.sourceInformationProvider = new VisualStudioSourceInformationProvider(assemblyFileName); #else this.sourceInformationProvider = new NullSourceInformationProvider(); #endif toDispose.Push(this.sourceInformationProvider); } }
Xunit2Discoverer(ISourceInformationProvider sourceInformationProvider, IAssemblyInfo assemblyInfo, string assemblyFileName, string xunitExecutionAssemblyPath, string configFileName, bool shadowCopy, string shadowCopyFolder) { Guard.ArgumentNotNull("assemblyInfo", (object)assemblyInfo ?? assemblyFileName); #if !ANDROID Guard.ArgumentValid("xunitExecutionAssemblyPath", "File not found: " + xunitExecutionAssemblyPath, File.Exists(xunitExecutionAssemblyPath)); #endif appDomain = new RemoteAppDomainManager(assemblyFileName ?? xunitExecutionAssemblyPath, configFileName, shadowCopy, shadowCopyFolder); #if !ANDROID var name = AssemblyName.GetAssemblyName(xunitExecutionAssemblyPath); var testFrameworkAssemblyName = name.FullName; #else var name = Assembly.Load(xunitExecutionAssemblyPath); var testFrameworkAssemblyName = name.FullName; #endif // If we didn't get an assemblyInfo object, we can leverage the reflection-based IAssemblyInfo wrapper if (assemblyInfo == null) assemblyInfo = appDomain.CreateObject<IAssemblyInfo>(testFrameworkAssemblyName, "Xunit.Sdk.ReflectionAssemblyInfo", assemblyFileName); framework = appDomain.CreateObject<ITestFramework>(testFrameworkAssemblyName, "Xunit.Sdk.TestFrameworkProxy", assemblyInfo, sourceInformationProvider); discoverer = Framework.GetDiscoverer(assemblyInfo); }
// Used by Xunit2 when initializing for both discovery and execution. internal Xunit2Discoverer(ISourceInformationProvider sourceInformationProvider, string assemblyFileName, string configFileName, bool shadowCopy, string shadowCopyFolder = null, IMessageSink diagnosticMessageSink = null) : this(sourceInformationProvider, null, assemblyFileName, GetXunitExecutionAssemblyPath(assemblyFileName), configFileName, shadowCopy, shadowCopyFolder, diagnosticMessageSink) { }
/// <summary> /// Initializes a new instance of the <see cref="T:Xunit.Sdk.XunitTestFrameworkExecutor"/> class. /// </summary> /// <param name="assemblyName">Name of the test assembly.</param><param name="sourceInformationProvider">The source line number information provider.</param><param name="diagnosticMessageSink">The message sink to report diagnostic messages to.</param> public BrowserTestFrameworkExecutor( AssemblyName assemblyName, ISourceInformationProvider sourceInformationProvider, IMessageSink diagnosticMessageSink) : base(assemblyName, sourceInformationProvider, diagnosticMessageSink) { }
Xunit2Discoverer(ISourceInformationProvider sourceInformationProvider, IAssemblyInfo assemblyInfo, string assemblyFileName, string xunitExecutionAssemblyPath, string configFileName, bool shadowCopy, string shadowCopyFolder, IMessageSink diagnosticMessageSink) { Guard.ArgumentNotNull("assemblyInfo", (object)assemblyInfo ?? assemblyFileName); Guard.FileExists("xunitExecutionAssemblyPath", xunitExecutionAssemblyPath); DiagnosticMessageSink = diagnosticMessageSink ?? new NullMessageSink(); appDomain = new RemoteAppDomainManager(assemblyFileName ?? xunitExecutionAssemblyPath, configFileName, shadowCopy, shadowCopyFolder); var testFrameworkAssemblyName = GetTestFrameworkAssemblyName(xunitExecutionAssemblyPath); // If we didn't get an assemblyInfo object, we can leverage the reflection-based IAssemblyInfo wrapper if (assemblyInfo == null) { assemblyInfo = appDomain.CreateObject <IAssemblyInfo>(testFrameworkAssemblyName, "Xunit.Sdk.ReflectionAssemblyInfo", assemblyFileName); } framework = appDomain.CreateObject <ITestFramework>(testFrameworkAssemblyName, "Xunit.Sdk.TestFrameworkProxy", assemblyInfo, sourceInformationProvider, DiagnosticMessageSink); discoverer = Framework.GetDiscoverer(assemblyInfo); }
/// <summary> /// Initializes a new instance of the <see cref="XunitFrontController"/> class. /// </summary> /// <param name="appDomainSupport">Determines whether tests should be run in a separate app domain.</param> /// <param name="assemblyFileName">The test assembly.</param> /// <param name="configFileName">The test assembly configuration file.</param> /// <param name="shadowCopy">If set to <c>true</c>, runs tests in a shadow copied app domain, which allows /// tests to be discovered and run without locking assembly files on disk.</param> /// <param name="shadowCopyFolder">The path on disk to use for shadow copying; if <c>null</c>, a folder /// will be automatically (randomly) generated</param> /// <param name="sourceInformationProvider">The source information provider. If <c>null</c>, uses the default (<see cref="T:Xunit.VisualStudioSourceInformationProvider"/>).</param> /// <param name="diagnosticMessageSink">The message sink which received <see cref="IDiagnosticMessage"/> messages.</param> public XunitFrontController(AppDomainSupport appDomainSupport, string assemblyFileName, string configFileName = null, bool shadowCopy = true, string shadowCopyFolder = null, ISourceInformationProvider sourceInformationProvider = null, IMessageSink diagnosticMessageSink = null) { this.appDomainSupport = appDomainSupport; this.assemblyFileName = assemblyFileName; this.configFileName = configFileName; this.shadowCopy = shadowCopy; this.shadowCopyFolder = shadowCopyFolder; this.sourceInformationProvider = sourceInformationProvider; this.diagnosticMessageSink = diagnosticMessageSink ?? new NullMessageSink(); Guard.FileExists("assemblyFileName", assemblyFileName); if (this.sourceInformationProvider == null) { #if NETSTANDARD1_1 this.sourceInformationProvider = new NullSourceInformationProvider(); #else this.sourceInformationProvider = new VisualStudioSourceInformationProvider(assemblyFileName); #endif toDispose.Push(this.sourceInformationProvider); } }
Xunit2Discoverer(ISourceInformationProvider sourceInformationProvider, IAssemblyInfo assemblyInfo, string assemblyFileName, string xunitExecutionAssemblyPath, string configFileName, bool shadowCopy, string shadowCopyFolder, IMessageSink diagnosticMessageSink) { Guard.ArgumentNotNull("assemblyInfo", (object)assemblyInfo ?? assemblyFileName); Guard.FileExists("xunitExecutionAssemblyPath", xunitExecutionAssemblyPath); DiagnosticMessageSink = diagnosticMessageSink ?? new NullMessageSink(); appDomain = new RemoteAppDomainManager(assemblyFileName ?? xunitExecutionAssemblyPath, configFileName, shadowCopy, shadowCopyFolder); var testFrameworkAssemblyName = GetTestFrameworkAssemblyName(xunitExecutionAssemblyPath); // If we didn't get an assemblyInfo object, we can leverage the reflection-based IAssemblyInfo wrapper if (assemblyInfo == null) assemblyInfo = appDomain.CreateObject<IAssemblyInfo>(testFrameworkAssemblyName, "Xunit.Sdk.ReflectionAssemblyInfo", assemblyFileName); framework = appDomain.CreateObject<ITestFramework>(testFrameworkAssemblyName, "Xunit.Sdk.TestFrameworkProxy", assemblyInfo, sourceInformationProvider, DiagnosticMessageSink); discoverer = Framework.GetDiscoverer(assemblyInfo); }
public static TestableXunitTestFrameworkDiscoverer Create(IAssemblyInfo assembly = null, ISourceInformationProvider sourceProvider = null, IMessageSink diagnosticMessageSink = null, IXunitTestCollectionFactory collectionFactory = null) { return(new TestableXunitTestFrameworkDiscoverer(assembly ?? Mocks.AssemblyInfo(), sourceProvider, diagnosticMessageSink, collectionFactory)); }
public ElasticTestFrameworkDiscoverer(IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider, IMessageSink diagnosticMessageSink, IXunitTestCollectionFactory collectionFactory = null) : base(assemblyInfo, sourceProvider, diagnosticMessageSink, collectionFactory) { var a = Assembly.Load(new AssemblyName(assemblyInfo.Name)); var options = a.GetCustomAttribute <ElasticXunitConfigurationAttribute>()?.Options ?? new ElasticXunitRunOptions(); this.Options = options; }
/// <summary> /// Initializes a new instance of the <see cref="XunitTestFrameworkDiscoverer"/> class. /// </summary> /// <param name="assemblyInfo">The test assembly.</param> /// <param name="sourceProvider">The source information provider.</param> /// <param name="messageAggregator">The message aggregator to receive environmental warnings from.</param> public TestFrameworkDiscoverer(IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider, IMessageAggregator messageAggregator) { Guard.ArgumentNotNull("assemblyInfo", assemblyInfo); Guard.ArgumentNotNull("sourceProvider", sourceProvider); Aggregator = messageAggregator ?? MessageAggregator.Instance; AssemblyInfo = assemblyInfo; DisposalTracker = new DisposalTracker(); SourceProvider = sourceProvider; targetFramework = new Lazy <string>(() => { string result = null; var attrib = AssemblyInfo.GetCustomAttributes(typeof(TargetFrameworkAttribute)).FirstOrDefault(); if (attrib != null) { result = attrib.GetConstructorArguments().Cast <string>().First(); } return(result ?? ""); }); }
public IntegrationTestFrameworkDiscoverer(IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider, IMessageSink diagnosticMessageSink) : base(assemblyInfo, sourceProvider, diagnosticMessageSink) { TestFrameworkDisplayName = "Integration Test Framework"; _testAssembly = new TestAssembly(assemblyInfo); }
public KuduXunitTestFrameworkDiscoverer(IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider, IMessageSink diagnosticMessageSink, IXunitTestCollectionFactory collectionFactory = null) : base(assemblyInfo, sourceProvider, diagnosticMessageSink, collectionFactory) { }
public BenchmarkTestFrameworkDiscoverer(IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceInformationProvider, IMessageSink diagnosticMessageSink) : base(assemblyInfo, sourceInformationProvider, diagnosticMessageSink) { var testAssembly = new TestAssembly(assemblyInfo, AppDomain.CurrentDomain.SetupInformation.ConfigurationFile); testCollectionFactory = new CollectionPerClassTestCollectionFactory(testAssembly, DiagnosticMessageSink); }
/// <summary> /// Initializes a new instance of the <see cref="XunitFrontController"/> class. /// </summary> /// <param name="assemblyFileName">The test assembly.</param> /// <param name="configFileName">The test assembly configuration file.</param> /// <param name="shadowCopy">If set to <c>true</c>, runs tests in a shadow copied app domain, which allows /// <param name="shadowCopyFolder">The path on disk to use for shadow copying; if <c>null</c>, a folder /// will be automatically (randomly) generated</param> /// <param name="sourceInformationProvider">The source information provider. If <c>null</c>, uses the default (<see cref="T:Xunit.VisualStudioSourceInformationProvider"/>).</param> /// tests to be discovered and run without locking assembly files on disk.</param> /// <param name="diagnosticMessageSink">The message sink which received <see cref="IDiagnosticMessage"/> messages.</param> public XunitFrontController(string assemblyFileName, string configFileName = null, bool shadowCopy = true, string shadowCopyFolder = null, ISourceInformationProvider sourceInformationProvider = null, IMessageSink diagnosticMessageSink = null) { this.assemblyFileName = assemblyFileName; this.configFileName = configFileName; this.shadowCopy = shadowCopy; this.shadowCopyFolder = shadowCopyFolder; this.sourceInformationProvider = sourceInformationProvider; this.diagnosticMessageSink = diagnosticMessageSink ?? new NullMessageSink(); Guard.FileExists("assemblyFileName", assemblyFileName); if (this.sourceInformationProvider == null) { #if !XAMARIN && !WINDOWS_PHONE_APP && !WINDOWS_PHONE this.sourceInformationProvider = new VisualStudioSourceInformationProvider(assemblyFileName); #else this.sourceInformationProvider = new NullSourceInformationProvider(); #endif toDispose.Push(this.sourceInformationProvider); } }
Xunit2Discoverer(AppDomainSupport appDomainSupport, ISourceInformationProvider sourceInformationProvider, IAssemblyInfo assemblyInfo, string assemblyFileName, string xunitExecutionAssemblyPath, string configFileName, bool shadowCopy, string shadowCopyFolder, IMessageSink diagnosticMessageSink, bool verifyAssembliesOnDisk) { Guard.ArgumentNotNull("assemblyInfo", (object)assemblyInfo ?? assemblyFileName); if (verifyAssembliesOnDisk) Guard.FileExists("xunitExecutionAssemblyPath", xunitExecutionAssemblyPath); #if PLATFORM_DOTNET CanUseAppDomains = false; #else CanUseAppDomains = !IsDotNet(xunitExecutionAssemblyPath); #endif DiagnosticMessageSink = diagnosticMessageSink ?? new NullMessageSink(); var appDomainAssembly = assemblyFileName ?? xunitExecutionAssemblyPath; appDomain = AppDomainManagerFactory.Create(appDomainSupport != AppDomainSupport.Denied && CanUseAppDomains, appDomainAssembly, configFileName, shadowCopy, shadowCopyFolder); var testFrameworkAssemblyName = GetTestFrameworkAssemblyName(xunitExecutionAssemblyPath); // If we didn't get an assemblyInfo object, we can leverage the reflection-based IAssemblyInfo wrapper if (assemblyInfo == null) assemblyInfo = appDomain.CreateObject<IAssemblyInfo>(testFrameworkAssemblyName, "Xunit.Sdk.ReflectionAssemblyInfo", assemblyFileName); framework = appDomain.CreateObject<ITestFramework>(testFrameworkAssemblyName, "Xunit.Sdk.TestFrameworkProxy", assemblyInfo, sourceInformationProvider, DiagnosticMessageSink); discoverer = Framework.GetDiscoverer(assemblyInfo); }
public AutofacTestFrameworkDiscoverer(IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider, IMessageSink diagnosticMessageSink) : base(assemblyInfo, sourceProvider, diagnosticMessageSink) { var testAssembly = new TestAssembly(assemblyInfo); _testCollectionFactory = new CollectionPerClassTestCollectionFactory(testAssembly, diagnosticMessageSink); }
/// <summary> /// Initializes a new instance of the <see cref="Xunit2"/> class. /// </summary> /// <param name="useAppDomain">Determines whether tests should be run in a separate app domain.</param> /// <param name="sourceInformationProvider">The source code information provider.</param> /// <param name="assemblyFileName">The test assembly.</param> /// <param name="configFileName">The test assembly configuration file.</param> /// <param name="shadowCopy">If set to <c>true</c>, runs tests in a shadow copied app domain, which allows /// tests to be discovered and run without locking assembly files on disk.</param> /// <param name="shadowCopyFolder">The path on disk to use for shadow copying; if <c>null</c>, a folder /// will be automatically (randomly) generated</param> /// <param name="diagnosticMessageSink">The message sink which received <see cref="IDiagnosticMessage"/> messages.</param> /// <param name="verifyTestAssemblyExists">Determines whether or not the existence of the test assembly is verified.</param> public Xunit2(bool useAppDomain, ISourceInformationProvider sourceInformationProvider, string assemblyFileName, string configFileName = null, bool shadowCopy = true, string shadowCopyFolder = null, IMessageSink diagnosticMessageSink = null, bool verifyTestAssemblyExists = true) : base(useAppDomain, sourceInformationProvider, assemblyFileName, configFileName, shadowCopy, shadowCopyFolder, diagnosticMessageSink, verifyTestAssemblyExists) { #if ANDROID var assemblyName = Assembly.Load(assemblyFileName).GetName(); #elif WINDOWS_PHONE_APP || WINDOWS_PHONE || DOTNETCORE // Make sure we only use the short form for WPA81 var an = Assembly.Load(new AssemblyName { Name = Path.GetFileNameWithoutExtension(assemblyFileName) }).GetName(); var assemblyName = new AssemblyName { Name = an.Name, Version = an.Version }; #else var assemblyName = AssemblyName.GetAssemblyName(assemblyFileName); #endif executor = Framework.GetExecutor(assemblyName); }
/// <summary> /// Initializes a new instance of the <see cref="T:Xunit.Sdk.XunitTestFrameworkExecutor"/> class. /// </summary> /// <param name="assemblyName">Name of the test assembly.</param><param name="sourceInformationProvider">The source line number information provider.</param><param name="diagnosticMessageSink">The message sink to report diagnostic messages to.</param> public ParallelTestFrameworkExecutor( AssemblyName assemblyName, ISourceInformationProvider sourceInformationProvider, IMessageSink diagnosticMessageSink) : base(assemblyName, sourceInformationProvider, diagnosticMessageSink) { }
Xunit2Discoverer(ISourceInformationProvider sourceInformationProvider, IAssemblyInfo assemblyInfo, string assemblyFileName, string xunitExecutionAssemblyPath, string configFileName, bool shadowCopy, string shadowCopyFolder) { Guard.ArgumentNotNull("assemblyInfo", (object)assemblyInfo ?? assemblyFileName); #if PLATFORM_LINUX || PLATFORM_MACOS appDomain = new RemoteAppDomainManager(assemblyFileName ?? xunitExecutionAssemblyPath, configFileName, shadowCopy, shadowCopyFolder); assemblyInfo = new Xunit.Sdk.ReflectionAssemblyInfo(assemblyFileName); framework = new Xunit.Sdk.TestFrameworkProxy(assemblyInfo, sourceInformationProvider); discoverer = framework.GetDiscoverer(assemblyInfo); #else Guard.FileExists("xunitExecutionAssemblyPath", xunitExecutionAssemblyPath); appDomain = new RemoteAppDomainManager(assemblyFileName ?? xunitExecutionAssemblyPath, configFileName, shadowCopy, shadowCopyFolder); var testFrameworkAssemblyName = GetTestFrameworkAssemblyName(xunitExecutionAssemblyPath); // If we didn't get an assemblyInfo object, we can leverage the reflection-based IAssemblyInfo wrapper if (assemblyInfo == null) { assemblyInfo = appDomain.CreateObject <IAssemblyInfo>(testFrameworkAssemblyName, "Xunit.Sdk.ReflectionAssemblyInfo", assemblyFileName); } framework = appDomain.CreateObject <ITestFramework>(testFrameworkAssemblyName, "Xunit.Sdk.TestFrameworkProxy", assemblyInfo, sourceInformationProvider); discoverer = Framework.GetDiscoverer(assemblyInfo); #endif }
/// <summary> /// Initializes a new instance of the <see cref="Xunit2"/> class. /// </summary> /// <param name="sourceInformationProvider">The source code information provider.</param> /// <param name="assemblyFileName">The test assembly.</param> /// <param name="configFileName">The test assembly configuration file.</param> /// <param name="shadowCopy">If set to <c>true</c>, runs tests in a shadow copied app domain, which allows /// tests to be discovered and run without locking assembly files on disk.</param> public Xunit2(ISourceInformationProvider sourceInformationProvider, string assemblyFileName, string configFileName = null, bool shadowCopy = true) : base(sourceInformationProvider, assemblyFileName, configFileName, shadowCopy) { AssemblyName assemblyName = AssemblyName.GetAssemblyName(assemblyFileName); executor = Framework.GetExecutor(assemblyName); }
Xunit2Discoverer(ISourceInformationProvider sourceInformationProvider, IAssemblyInfo assemblyInfo, string assemblyFileName, string xunitExecutionAssemblyPath, string configFileName, bool shadowCopy, string shadowCopyFolder) { Guard.ArgumentNotNull("assemblyInfo", (object)assemblyInfo ?? assemblyFileName); #if !ANDROID Guard.ArgumentValid("xunitExecutionAssemblyPath", "File not found: " + xunitExecutionAssemblyPath, File.Exists(xunitExecutionAssemblyPath)); #endif appDomain = new RemoteAppDomainManager(assemblyFileName ?? xunitExecutionAssemblyPath, configFileName, shadowCopy, shadowCopyFolder); #if !ANDROID var name = AssemblyName.GetAssemblyName(xunitExecutionAssemblyPath); var testFrameworkAssemblyName = name.FullName; #else var name = Assembly.Load(xunitExecutionAssemblyPath); var testFrameworkAssemblyName = name.FullName; #endif // If we didn't get an assemblyInfo object, we can leverage the reflection-based IAssemblyInfo wrapper if (assemblyInfo == null) { assemblyInfo = appDomain.CreateObject <IAssemblyInfo>(testFrameworkAssemblyName, "Xunit.Sdk.ReflectionAssemblyInfo", assemblyFileName); } framework = appDomain.CreateObject <ITestFramework>(testFrameworkAssemblyName, "Xunit.Sdk.TestFrameworkProxy", assemblyInfo, sourceInformationProvider); discoverer = Framework.GetDiscoverer(assemblyInfo); }
public CustomDiscoverer(IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider, IMessageSink diagnosticMessageSink, IXunitTestCollectionFactory collectionFactory = null) : base(assemblyInfo, sourceProvider, diagnosticMessageSink, collectionFactory) { tests = new HashSet <string>(); }
public KuduXunitTestFrameworkDiscoverer(IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider, IMessageSink diagnosticMessageSink, IXunitTestCollectionFactory collectionFactory = null) : base(assemblyInfo, sourceProvider, diagnosticMessageSink, collectionFactory) { _privateEnv = typeof(KuduXunitTestFrameworkDiscoverer).Assembly.GetType("Kudu.TestHarness.Antares.AntaresEnvironment") != null; }
public PerfTestDiscoverer( IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider, IMessageSink diagnosticMessageSink) : base(assemblyInfo, sourceProvider, diagnosticMessageSink) { _testConfig = new TestConfig(); }
/// <summary> /// Initializes a new instance of the <see cref="XunitTestFrameworkExecutor"/> class. /// </summary> /// <param name="assemblyName">Name of the test assembly.</param> /// <param name="sourceInformationProvider">The source line number information provider.</param> public XunitTestFrameworkExecutor(AssemblyName assemblyName, ISourceInformationProvider sourceInformationProvider) { this.sourceInformationProvider = sourceInformationProvider; var assembly = Assembly.Load(assemblyName); assemblyInfo = Reflector.Wrap(assembly); assemblyFileName = assemblyInfo.AssemblyPath; }
/// <summary> /// Initializes a new instance of the <see cref="Xunit2Discoverer"/> class. /// </summary> /// <param name="sourceInformationProvider">The source code information provider.</param> /// <param name="assemblyInfo">The assembly to use for discovery</param> /// <param name="xunitExecutionAssemblyPath">The path on disk of xunit.execution.dll; if <c>null</c>, then /// the location of xunit.execution.dll is implied based on the location of the test assembly</param> /// <param name="shadowCopyFolder">The path on disk to use for shadow copying; if <c>null</c>, a folder /// will be automatically (randomly) generated</param> /// <param name="diagnosticMessageSink">The message sink which received <see cref="IDiagnosticMessage"/> messages.</param> public Xunit2Discoverer(ISourceInformationProvider sourceInformationProvider, IAssemblyInfo assemblyInfo, string xunitExecutionAssemblyPath = null, string shadowCopyFolder = null, IMessageSink diagnosticMessageSink = null) : this(sourceInformationProvider, assemblyInfo, null, xunitExecutionAssemblyPath ?? GetXunitExecutionAssemblyPath(assemblyInfo), null, true, shadowCopyFolder, diagnosticMessageSink) { }
/// <summary> /// Initializes a new instance of the <see cref="XunitTestFrameworkExecutor"/> class. /// </summary> /// <param name="assemblyFileName">Path of the test assembly.</param> /// <param name="sourceInformationProvider">The source line number information provider.</param> public XunitTestFrameworkExecutor(string assemblyFileName, ISourceInformationProvider sourceInformationProvider) { this.assemblyFileName = assemblyFileName; this.sourceInformationProvider = sourceInformationProvider; var assembly = Assembly.Load(AssemblyName.GetAssemblyName(assemblyFileName)); assemblyInfo = Reflector.Wrap(assembly); }
/// <summary> /// Initializes a new instance of the <see cref="Xunit1"/> class. /// </summary> /// <param name="sourceInformationProvider">Source code information provider.</param> /// <param name="assemblyFileName">The test assembly.</param> /// <param name="configFileName">The test assembly configuration file.</param> /// <param name="shadowCopy">If set to <c>true</c>, runs tests in a shadow copied app domain, which allows /// tests to be discovered and run without locking assembly files on disk.</param> /// <param name="shadowCopyFolder">The path on disk to use for shadow copying; if <c>null</c>, a folder /// will be automatically (randomly) generated</param> public Xunit1(ISourceInformationProvider sourceInformationProvider, string assemblyFileName, string configFileName = null, bool shadowCopy = true, string shadowCopyFolder = null) { this.sourceInformationProvider = sourceInformationProvider; this.assemblyFileName = assemblyFileName; this.configFileName = configFileName; executor = CreateExecutor(assemblyFileName, configFileName, shadowCopy, shadowCopyFolder); }
public TestFrameworkDiscoverer(IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider, IMessageSink diagnosticMessageSink, IList <AssemblyLoaderAttribute> assemblyLoaders, IXunitTestCollectionFactory collectionFactory = null) : base(assemblyInfo, sourceProvider, diagnosticMessageSink, collectionFactory) { foreach (var assemblyLoader in assemblyLoaders) { DisposalTracker.Add(assemblyLoader); } }
public ObservationDiscoverer(IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider, IMessageSink diagnosticMessageSink) : base(assemblyInfo, sourceProvider, diagnosticMessageSink) { var testAssembly = new TestAssembly(assemblyInfo, AppDomain.CurrentDomain.SetupInformation.ConfigurationFile); testCollectionFactory = new CollectionPerClassTestCollectionFactory(testAssembly, diagnosticMessageSink); }
/// <summary> /// Initializes a new instance of the <see cref="Xunit2Discoverer"/> class. /// </summary> /// <param name="appDomainSupport">Determines whether tests should be run in a separate app domain.</param> /// <param name="sourceInformationProvider">The source code information provider.</param> /// <param name="assemblyInfo">The assembly to use for discovery</param> /// <param name="xunitExecutionAssemblyPath">The path on disk of xunit.execution.dll; if <c>null</c>, then /// the location of xunit.execution.dll is implied based on the location of the test assembly</param> /// <param name="shadowCopyFolder">The path on disk to use for shadow copying; if <c>null</c>, a folder /// will be automatically (randomly) generated</param> /// <param name="diagnosticMessageSink">The message sink which received <see cref="IDiagnosticMessage"/> messages.</param> /// <param name="verifyAssembliesOnDisk">Determines whether or not to check for the existence of assembly files.</param> public Xunit2Discoverer(AppDomainSupport appDomainSupport, ISourceInformationProvider sourceInformationProvider, IAssemblyInfo assemblyInfo, string xunitExecutionAssemblyPath = null, string shadowCopyFolder = null, IMessageSink diagnosticMessageSink = null, bool verifyAssembliesOnDisk = true) : this(appDomainSupport, sourceInformationProvider, assemblyInfo, null, xunitExecutionAssemblyPath ?? GetXunitExecutionAssemblyPath(appDomainSupport, assemblyInfo), null, true, shadowCopyFolder, diagnosticMessageSink, verifyAssembliesOnDisk) { }
public TestFrameworkExecutor( Logger logger, AssemblyName assemblyName, ISourceInformationProvider sourceInformationProvider, IMessageSink diagnosticMessageSink) : base(assemblyName, sourceInformationProvider, diagnosticMessageSink) { m_logger = logger; }
public ScenarioReportingXunitTestFrameworkDiscoverer(IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider, IMessageSink diagnosticMessageSink, IXunitTestCollectionFactory collectionFactory = null) : base(assemblyInfo, sourceProvider, diagnosticMessageSink) { DiscovererTypeCache[typeof(FactAttribute)] = typeof(ScenarioFactAttributeDiscoverer); DiscovererTypeCache[typeof(TheoryAttribute)] = typeof(ScenarioTheoryAttributeDiscoverer); }
public AutofacTestFrameworkExecutor(AssemblyName assemblyName, IContainer container, ISourceInformationProvider sourceInformationProvider, IMessageSink diagnosticMessageSink) : base(assemblyName, sourceInformationProvider, diagnosticMessageSink) { _container = container; _testAssembly = new TestAssembly(AssemblyInfo); }
public FusonicTestFrameworkDiscoverer( IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider, IMessageSink diagnosticMessageSink, IXunitTestCollectionFactory?collectionFactory = null) : base(assemblyInfo, sourceProvider, diagnosticMessageSink, collectionFactory) { DiscovererTypeCache[typeof(FactAttribute)] = typeof(FusonicFactDiscoverer); DiscovererTypeCache[typeof(TheoryAttribute)] = typeof(FusonicTheoryDiscoverer); }
/// <summary> /// Initializes a new instance of the <see cref="Xunit1"/> class. /// </summary> /// <param name="sourceInformationProvider">Source code information provider.</param> /// <param name="assemblyFileName">The test assembly.</param> /// <param name="configFileName">The test assembly configuration file.</param> /// <param name="shadowCopy">If set to <c>true</c>, runs tests in a shadow copied app domain, which allows /// tests to be discovered and run without locking assembly files on disk.</param> public Xunit1(ISourceInformationProvider sourceInformationProvider, string assemblyFileName, string configFileName = null, bool shadowCopy = true) { this.sourceInformationProvider = sourceInformationProvider; this.assemblyFileName = assemblyFileName; this.configFileName = configFileName; executor = CreateExecutor(assemblyFileName, configFileName, shadowCopy); testCollection = new Xunit1TestCollection(assemblyFileName); }
/// <summary> /// Initializes a new instance of the <see cref="XunitTestFrameworkExecutor"/> class. /// </summary> /// <param name="assemblyName">Name of the test assembly.</param> /// <param name="configFileName">The test configuration file.</param> /// <param name="sourceInformationProvider">The source line number information provider.</param> /// <param name="diagnosticMessageSink">The message sink to report diagnostic messages to.</param> public XunitTestFrameworkExecutor(AssemblyName assemblyName, string configFileName, ISourceInformationProvider sourceInformationProvider, IMessageSink diagnosticMessageSink) : base(assemblyName, sourceInformationProvider, diagnosticMessageSink) { TestAssembly = new TestAssembly(AssemblyInfo, configFileName, assemblyName.Version); discoverer = new Lazy <XunitTestFrameworkDiscoverer>(() => new XunitTestFrameworkDiscoverer(AssemblyInfo, configFileName, SourceInformationProvider, DiagnosticMessageSink)); }
public SpecThisTestFrameworkDiscoverer(IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider, IMessageSink diagnosticMessageSink, IXunitTestCollectionFactory collectionFactory = null) : base(assemblyInfo, sourceProvider, diagnosticMessageSink) { IAttributeInfo collectionBehaviorAttribute = assemblyInfo.GetCustomAttributes(typeof(CollectionBehaviorAttribute)).SingleOrDefault<IAttributeInfo>(); bool flag = collectionBehaviorAttribute != null && collectionBehaviorAttribute.GetNamedArgument<bool>("DisableTestParallelization"); string configurationFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile; TestAssembly testAssembly = new TestAssembly(assemblyInfo, configurationFile); this.TestCollectionFactory = collectionFactory ?? ExtensibilityPointFactory.GetXunitTestCollectionFactory(diagnosticMessageSink, collectionBehaviorAttribute, (ITestAssembly)testAssembly); this.TestFrameworkDisplayName = string.Format("{0} [{1}, {2}]", XunitTestFrameworkDiscoverer.DisplayName, this.TestCollectionFactory.DisplayName, flag ? "non-parallel" : "parallel"); }
// Used by Xunit2 when initializing for both discovery and execution. internal Xunit2Discoverer(AppDomainSupport appDomainSupport, ISourceInformationProvider sourceInformationProvider, string assemblyFileName, string configFileName, bool shadowCopy, string shadowCopyFolder = null, IMessageSink diagnosticMessageSink = null, bool verifyAssembliesOnDisk = true) : this(appDomainSupport, sourceInformationProvider, null, assemblyFileName, GetXunitExecutionAssemblyPath(appDomainSupport, assemblyFileName, verifyAssembliesOnDisk), configFileName, shadowCopy, shadowCopyFolder, diagnosticMessageSink, verifyAssembliesOnDisk) { }
/// <summary> /// Initializes a new instance of the <see cref="Xunit2"/> class. /// </summary> /// <param name="sourceInformationProvider">The source code information provider.</param> /// <param name="assemblyFileName">The test assembly.</param> /// <param name="configFileName">The test assembly configuration file.</param> /// <param name="shadowCopy">If set to <c>true</c>, runs tests in a shadow copied app domain, which allows /// tests to be discovered and run without locking assembly files on disk.</param> /// <param name="shadowCopyFolder">The path on disk to use for shadow copying; if <c>null</c>, a folder /// will be automatically (randomly) generated</param> public Xunit2(ISourceInformationProvider sourceInformationProvider, string assemblyFileName, string configFileName = null, bool shadowCopy = true, string shadowCopyFolder = null) : base(sourceInformationProvider, assemblyFileName, configFileName, shadowCopy, shadowCopyFolder) { #if !ANDROID AssemblyName assemblyName = AssemblyName.GetAssemblyName(assemblyFileName); #else var assm = Assembly.Load(assemblyFileName); AssemblyName assemblyName = assm.GetName(); #endif executor = Framework.GetExecutor(assemblyName); }
/// <summary> /// Initializes a new instance of the <see cref="XunitTestFrameworkDiscoverer"/> class. /// </summary> /// <param name="assemblyInfo">The test assembly.</param> /// <param name="sourceProvider">The source information provider.</param> /// <param name="messageAggregator">The message aggregator to receive environmental warnings from.</param> public TestFrameworkDiscoverer(IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider, IMessageAggregator messageAggregator) { Guard.ArgumentNotNull("assemblyInfo", assemblyInfo); Guard.ArgumentNotNull("sourceProvider", sourceProvider); Aggregator = messageAggregator ?? MessageAggregator.Instance; AssemblyInfo = assemblyInfo; DisposalTracker = new DisposalTracker(); SourceProvider = sourceProvider; }
Xunit2Discoverer(ISourceInformationProvider sourceInformationProvider, IAssemblyInfo assemblyInfo, string assemblyFileName, string xunit2AssemblyPath, string configFileName, bool shadowCopy) { Guard.ArgumentNotNull("assemblyInfo", (object)assemblyInfo ?? assemblyFileName); Guard.ArgumentValid("xunit2AssemblyPath", "File not found: " + xunit2AssemblyPath, File.Exists(xunit2AssemblyPath)); framework = new AppDomainTestFramework(sourceInformationProvider, assemblyFileName, xunit2AssemblyPath, "Xunit.Sdk.XunitTestFramework", configFileName, shadowCopy); // If we didn't get an assemblyInfo object, we can leverage the reflection-based IAssemblyInfo wrapper if (assemblyInfo == null) assemblyInfo = framework.CreateRemoteObject<IAssemblyInfo>("Xunit.Sdk.ReflectionAssemblyInfo", assemblyFileName); discoverer = Framework.GetDiscoverer(assemblyInfo); }
/// <summary> /// Initializes a new instance of the <see cref="Xunit2"/> class. /// </summary> /// <param name="sourceInformationProvider">The source code information provider.</param> /// <param name="assemblyFileName">The test assembly.</param> /// <param name="configFileName">The test assembly configuration file.</param> /// <param name="shadowCopy">If set to <c>true</c>, runs tests in a shadow copied app domain, which allows /// tests to be discovered and run without locking assembly files on disk.</param> /// <param name="shadowCopyFolder">The path on disk to use for shadow copying; if <c>null</c>, a folder /// will be automatically (randomly) generated</param> public Xunit2(ISourceInformationProvider sourceInformationProvider, string assemblyFileName, string configFileName = null, bool shadowCopy = true, string shadowCopyFolder = null) : base(sourceInformationProvider, assemblyFileName, configFileName, shadowCopy, shadowCopyFolder) { #if ANDROID var assm = Assembly.Load(assemblyFileName); var assemblyName = assm.GetName(); #elif WINDOWS_PHONE_APP || WINDOWS_PHONE || ASPNET50 || ASPNETCORE50 var assm = Assembly.Load(new AssemblyName { Name = Path.GetFileNameWithoutExtension(assemblyFileName) }); var assemblyName = new AssemblyName { Name = assm.GetName().Name }; #else var assemblyName = AssemblyName.GetAssemblyName(assemblyFileName); #endif executor = Framework.GetExecutor(assemblyName); }
/// <summary> /// Initializes a new instance of the <see cref="XunitTestFrameworkDiscoverer"/> class. /// </summary> /// <param name="assemblyInfo">The test assembly.</param> /// <param name="sourceProvider">The source information provider.</param> /// <param name="collectionFactory">The test collection factory used to look up test collections.</param> /// <param name="messageAggregator">The message aggregator to receive environmental warnings from.</param> public XunitTestFrameworkDiscoverer(IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider, IXunitTestCollectionFactory collectionFactory, IMessageAggregator messageAggregator) { Guard.ArgumentNotNull("assemblyInfo", assemblyInfo); Guard.ArgumentNotNull("sourceProvider", sourceProvider); this.assemblyInfo = assemblyInfo; this.sourceProvider = sourceProvider; this.messageAggregator = messageAggregator ?? MessageAggregator.Instance; TestCollectionFactory = collectionFactory ?? GetTestCollectionFactory(this.assemblyInfo); TestFrameworkDisplayName = String.Format("{0} [{1}, non-parallel]", DisplayName, TestCollectionFactory.DisplayName); }
/// <summary> /// Initializes a new instance of the <see cref="XunitTestFrameworkDiscoverer"/> class. /// </summary> /// <param name="assemblyInfo">The test assembly.</param> /// <param name="sourceProvider">The source information provider.</param> /// <param name="collectionFactory">The test collection factory used to look up test collections.</param> /// <param name="messageAggregator">The message aggregator to receive environmental warnings from.</param> public XunitTestFrameworkDiscoverer(IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider, IXunitTestCollectionFactory collectionFactory, IMessageAggregator messageAggregator) : base(assemblyInfo, sourceProvider, messageAggregator) { var collectionBehaviorAttribute = assemblyInfo.GetCustomAttributes(typeof(CollectionBehaviorAttribute)).SingleOrDefault(); var disableParallelization = collectionBehaviorAttribute == null ? false : collectionBehaviorAttribute.GetNamedArgument<bool>("DisableTestParallelization"); TestCollectionFactory = collectionFactory ?? GetTestCollectionFactory(this.AssemblyInfo, collectionBehaviorAttribute); TestFrameworkDisplayName = String.Format("{0} [{1}, {2}]", DisplayName, TestCollectionFactory.DisplayName, disableParallelization ? "non-parallel" : "parallel"); }
/// <summary> /// Initializes a new instance of the <see cref="XunitFrontController"/> class. /// </summary> /// <param name="assemblyFileName">The test assembly.</param> /// <param name="configFileName">The test assembly configuration file.</param> /// <param name="shadowCopy">If set to <c>true</c>, runs tests in a shadow copied app domain, which allows /// <param name="sourceInformationProvider">The source information provider. If <c>null</c>, uses the default (<see cref="VisualStudioSourceInformationProvider"/>).</param> /// tests to be discovered and run without locking assembly files on disk.</param> public XunitFrontController(string assemblyFileName, string configFileName = null, bool shadowCopy = true, ISourceInformationProvider sourceInformationProvider = null) { this.assemblyFileName = assemblyFileName; this.configFileName = configFileName; this.shadowCopy = shadowCopy; this.sourceInformationProvider = sourceInformationProvider; Guard.FileExists("assemblyFileName", assemblyFileName); if (this.sourceInformationProvider == null) { this.sourceInformationProvider = new VisualStudioSourceInformationProvider(assemblyFileName); toDispose.Push(this.sourceInformationProvider); } }
/// <summary> /// Initializes a new instance of the <see cref="Xunit2"/> class. /// </summary> /// <param name="appDomainSupport">Determines whether tests should be run in a separate app domain.</param> /// <param name="sourceInformationProvider">The source code information provider.</param> /// <param name="assemblyFileName">The test assembly.</param> /// <param name="configFileName">The test assembly configuration file.</param> /// <param name="shadowCopy">If set to <c>true</c>, runs tests in a shadow copied app domain, which allows /// tests to be discovered and run without locking assembly files on disk.</param> /// <param name="shadowCopyFolder">The path on disk to use for shadow copying; if <c>null</c>, a folder /// will be automatically (randomly) generated</param> /// <param name="diagnosticMessageSink">The message sink which received <see cref="IDiagnosticMessage"/> messages.</param> /// <param name="verifyTestAssemblyExists">Determines whether or not the existence of the test assembly is verified.</param> public Xunit2(AppDomainSupport appDomainSupport, ISourceInformationProvider sourceInformationProvider, string assemblyFileName, string configFileName = null, bool shadowCopy = true, string shadowCopyFolder = null, IMessageSink diagnosticMessageSink = null, bool verifyTestAssemblyExists = true) : base(appDomainSupport, sourceInformationProvider, assemblyFileName, configFileName, shadowCopy, shadowCopyFolder, diagnosticMessageSink, verifyTestAssemblyExists) { #if PLATFORM_DOTNET var an = Assembly.Load(new AssemblyName { Name = Path.GetFileNameWithoutExtension(assemblyFileName) }).GetName(); var assemblyName = new AssemblyName { Name = an.Name, Version = an.Version }; #else var assemblyName = AssemblyName.GetAssemblyName(assemblyFileName); #endif executor = Framework.GetExecutor(assemblyName); }
readonly Dictionary<Type, Type> discovererTypeCache = new Dictionary<Type, Type>(); // key is a Type that is or derives from FactAttribute /// <summary> /// Initializes a new instance of the <see cref="XunitTestFrameworkDiscoverer"/> class. /// </summary> /// <param name="assemblyInfo">The test assembly.</param> /// <param name="sourceProvider">The source information provider.</param> /// <param name="diagnosticMessageSink">The message sink used to send diagnostic messages</param> /// <param name="collectionFactory">The test collection factory used to look up test collections.</param> public XunitTestFrameworkDiscoverer(IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider, IMessageSink diagnosticMessageSink, IXunitTestCollectionFactory collectionFactory = null) : base(assemblyInfo, sourceProvider, diagnosticMessageSink) { var collectionBehaviorAttribute = assemblyInfo.GetCustomAttributes(typeof(CollectionBehaviorAttribute)).SingleOrDefault(); var disableParallelization = collectionBehaviorAttribute != null && collectionBehaviorAttribute.GetNamedArgument<bool>("DisableTestParallelization"); string config = null; #if !PLATFORM_DOTNET config = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile; #endif var testAssembly = new TestAssembly(assemblyInfo, config); TestCollectionFactory = collectionFactory ?? ExtensibilityPointFactory.GetXunitTestCollectionFactory(diagnosticMessageSink, collectionBehaviorAttribute, testAssembly); TestFrameworkDisplayName = $"{DisplayName} [{TestCollectionFactory.DisplayName}, {(disableParallelization ? "non-parallel" : "parallel")}]"; }
/// <summary> /// Initializes a new instance of the <see cref="XunitFrontController"/> class. /// </summary> /// <param name="assemblyFileName">The test assembly.</param> /// <param name="configFileName">The test assembly configuration file.</param> /// <param name="shadowCopy">If set to <c>true</c>, runs tests in a shadow copied app domain, which allows /// <param name="sourceInformationProvider">The source information provider. If <c>null</c>, uses the default (<see cref="VisualStudioSourceInformationProvider"/>).</param> /// tests to be discovered and run without locking assembly files on disk.</param> public XunitFrontController(string assemblyFileName, string configFileName = null, bool shadowCopy = true, ISourceInformationProvider sourceInformationProvider = null) { Guard.FileExists("assemblyFileName", assemblyFileName); var xunit1Path = Path.Combine(Path.GetDirectoryName(assemblyFileName), "xunit.dll"); var xunit2Path = Path.Combine(Path.GetDirectoryName(assemblyFileName), "xunit2.dll"); if (sourceInformationProvider == null) { sourceInformationProvider = new VisualStudioSourceInformationProvider(assemblyFileName); createdSourceInformationProvider = sourceInformationProvider; } if (File.Exists(xunit2Path)) innerController = new Xunit2(sourceInformationProvider, assemblyFileName, configFileName, shadowCopy); else if (File.Exists(xunit1Path)) innerController = new Xunit1(sourceInformationProvider, assemblyFileName, configFileName, shadowCopy); else throw new ArgumentException("Unknown test framework: Could not find xunit.dll or xunit2.dll.", assemblyFileName); }
/// <summary> /// Initializes a new instance of the <see cref="Xunit2"/> class. /// </summary> /// <param name="sourceInformationProvider">The source code information provider.</param> /// <param name="assemblyFileName">The test assembly.</param> /// <param name="configFileName">The test assembly configuration file.</param> /// <param name="shadowCopy">If set to <c>true</c>, runs tests in a shadow copied app domain, which allows /// tests to be discovered and run without locking assembly files on disk.</param> /// <param name="shadowCopyFolder">The path on disk to use for shadow copying; if <c>null</c>, a folder /// will be automatically (randomly) generated</param> /// <param name="diagnosticMessageSink">The message sink which received <see cref="IDiagnosticMessage"/> messages.</param> public Xunit2(ISourceInformationProvider sourceInformationProvider, string assemblyFileName, string configFileName = null, bool shadowCopy = true, string shadowCopyFolder = null, IMessageSink diagnosticMessageSink = null) : base(sourceInformationProvider, assemblyFileName, configFileName, shadowCopy, shadowCopyFolder, diagnosticMessageSink) { #if ANDROID var assm = Assembly.Load(assemblyFileName); var assemblyName = assm.GetName(); #elif WINDOWS_PHONE_APP || WINDOWS_PHONE || DNX451 || DNXCORE50 var assm = Assembly.Load(new AssemblyName { Name = Path.GetFileNameWithoutExtension(assemblyFileName) }); var assemblyName = new AssemblyName { Name = assm.GetName().Name, Version = new Version(0, 0, 0, 0) }; #else var assemblyName = AssemblyName.GetAssemblyName(assemblyFileName); #endif executor = Framework.GetExecutor(assemblyName); }
/// <summary> /// Initializes a new instance of the <see cref="XunitTestFrameworkDiscoverer"/> class. /// </summary> /// <param name="assemblyInfo">The test assembly.</param> /// <param name="sourceProvider">The source information provider.</param> /// <param name="diagnosticMessageSink">The message sink used to send diagnostic messages</param> /// <param name="collectionFactory">The test collection factory used to look up test collections.</param> public XunitTestFrameworkDiscoverer(IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider, IMessageSink diagnosticMessageSink, IXunitTestCollectionFactory collectionFactory = null) : base(assemblyInfo, sourceProvider, diagnosticMessageSink) { var collectionBehaviorAttribute = assemblyInfo.GetCustomAttributes(typeof(CollectionBehaviorAttribute)).SingleOrDefault(); var disableParallelization = collectionBehaviorAttribute == null ? false : collectionBehaviorAttribute.GetNamedArgument<bool>("DisableTestParallelization"); string config = null; #if !WINDOWS_PHONE_APP && !WINDOWS_PHONE && !DNXCORE50 config = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile; #endif var testAssembly = new TestAssembly(assemblyInfo, config); TestCollectionFactory = collectionFactory ?? ExtensibilityPointFactory.GetXunitTestCollectionFactory(diagnosticMessageSink, collectionBehaviorAttribute, testAssembly); TestFrameworkDisplayName = string.Format("{0} [{1}, {2}]", DisplayName, TestCollectionFactory.DisplayName, disableParallelization ? "non-parallel" : "parallel"); }