private void BuildFixturesFromType(Test parent, ITypeInfo type)
{
try
{
foreach (TestFixturePatternAttribute2 attrib in AttributeUtils.GetAttributes <TestFixturePatternAttribute2>(type, true))
{
BuildTestFixtureFromPatternAttribute(parent, type, attrib);
}
}
catch (Exception ex)
{
testModel.AddAnnotation(new Annotation(AnnotationType.Error, type,
"An exception was thrown while exploring an MbUnit v2 test type.", ex));
}
}
private Test TryGetTypeTest(ITypeInfo type, Test assemblyTest)
{
Test typeTest;
if (!typeTests.TryGetValue(type, out typeTest))
{
try
{
XunitTypeInfoAdapter xunitTypeInfo = new XunitTypeInfoAdapter(type);
ITestClassCommand command = TestClassCommandFactory.Make(xunitTypeInfo);
if (command != null)
{
typeTest = CreateTypeTest(xunitTypeInfo, command);
}
}
catch (Exception ex)
{
TestModel.AddAnnotation(new Annotation(AnnotationType.Error, type, "An exception was thrown while exploring an xUnit.net test type.", ex));
}
if (typeTest != null)
{
assemblyTest.AddChild(typeTest);
typeTests.Add(type, typeTest);
}
}
return(typeTest);
}
private Test TryGetTypeTest(ITypeInfo type, Test assemblyTest)
{
Test typeTest;
if (!typeTests.TryGetValue(type, out typeTest))
{
try
{
foreach (var attribute in type.GetAttributes(null, false))
{
if (attribute is ConcordionTestAttribute)
{
typeTest = CreateTypeTest(new ConcordionTypeInfoAdapter(type));
break;
}
}
}
catch (Exception ex)
{
TestModel.AddAnnotation(new Annotation(AnnotationType.Error, type, "An exception was thrown while exploring an concordion test type.", ex));
}
if (typeTest != null)
{
assemblyTest.AddChild(typeTest);
typeTests.Add(type, typeTest);
}
}
return(typeTest);
}
private Test TryGetTypeTest(ITypeInfo type, Test assemblyTest)
{
Test typeTest;
if (!typeTests.TryGetValue(type, out typeTest))
{
try
{
if (IsFixture(type))
{
typeTest = CreateTypeTest(type);
}
}
catch (Exception ex)
{
TestModel.AddAnnotation(new Annotation(AnnotationType.Error, type, "An exception was thrown while exploring an MSTest test type.", ex));
}
if (typeTest != null)
{
assemblyTest.AddChild(typeTest);
typeTests.Add(type, typeTest);
}
}
return(typeTest);
}
/// <summary>
/// Creates a message sink that populates the test model as test and annotation
/// discovered messages are published.
/// </summary>
/// <param name="testModel">The test model to populate.</param>
/// <returns>The message sink.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="testModel"/> is null.</exception>
public static IMessageSink CreateMessageSinkToPopulateTestModel(TestModel testModel)
{
if (testModel == null)
{
throw new ArgumentNullException("testModel");
}
return(new MessageConsumer()
.Handle <TestDiscoveredMessage>(message =>
{
Test test = message.Test.ToTest();
if (message.ParentTestId != null)
{
Test parentTest = testModel.FindTest(message.ParentTestId);
if (parentTest == null)
{
throw new InvalidOperationException("The parent test is missing.");
}
parentTest.AddChild(test);
}
else
{
testModel.RootTest = test;
}
})
.Handle <AnnotationDiscoveredMessage>(message =>
{
testModel.AddAnnotation(message.Annotation.ToAnnotation());
}));
}
protected override void ExploreImpl(IReflectionPolicy reflectionPolicy, ICodeElementInfo codeElement)
{
IAssemblyInfo assembly = ReflectionUtils.GetAssembly(codeElement);
if (assembly == null)
{
return;
}
try
{
MbUnit2TestExplorerEngine engine;
if (!assemblyTestExplorerEngines.TryGetValue(assembly, out engine))
{
Assembly loadedAssembly = assembly.Resolve(false);
if (Reflector.IsUnresolved(loadedAssembly))
{
engine = new MbUnit2ReflectiveTestExplorerEngine(TestModel, assembly);
}
else
{
engine = new MbUnit2NativeTestExplorerEngine(TestModel, loadedAssembly);
}
assemblyTestExplorerEngines.Add(assembly, engine);
bool skipChildren = !(codeElement is IAssemblyInfo);
engine.ExploreAssembly(skipChildren, unresolvedDependencies);
for (int i = 0; i < unresolvedDependencies.Count; i++)
{
foreach (var entry in assemblyTestExplorerEngines)
{
if (entry.Key.FullName == unresolvedDependencies[i].Value)
{
unresolvedDependencies[i].Key.AddDependency(entry.Value.GetAssemblyTest());
unresolvedDependencies.RemoveAt(i--);
break;
}
}
}
}
ITypeInfo type = ReflectionUtils.GetType(codeElement);
if (type != null)
{
engine.ExploreType(type);
}
}
catch (Exception ex)
{
TestModel.AddAnnotation(new Annotation(AnnotationType.Error, assembly,
"An exception was thrown while exploring an MbUnit v2 test assembly.", ex));
}
}
public override void Finish()
{
try
{
foreach (NUnitTestExplorerEngine engine in assemblyTestExplorerEngines.Values)
{
engine.Finish();
}
}
catch (Exception ex)
{
TestModel.AddAnnotation(new Annotation(AnnotationType.Error, null,
"An exception was thrown while finishing the population of the NUnit test model.", ex));
}
base.Finish();
}
private TestModel PublishTestModelFromCodeElements(IEnumerable <ICodeElementInfo> codeElements, IMessageSink messageSink, IProgressMonitor progressMonitor)
{
TestModel testModel = new TestModel();
var tests = new Dictionary <ICodeElementInfo, Test>();
foreach (ICodeElementInfo codeElement in codeElements)
{
if (progressMonitor.IsCanceled)
{
return(null);
}
testModel.AddAnnotation(new Annotation(AnnotationType.Warning, codeElement, FallbackExplanation));
IAssemblyInfo assembly = ReflectionUtils.GetAssembly(codeElement);
if (assembly != null)
{
Test assemblyTest;
if (!tests.TryGetValue(assembly, out assemblyTest))
{
assemblyTest = CreateTest(Path.GetFileName(assembly.Path), assembly);
testModel.RootTest.AddChild(assemblyTest);
tests.Add(assembly, assemblyTest);
ITypeInfo type = ReflectionUtils.GetType(codeElement);
if (type != null)
{
Test typeTest;
if (!tests.TryGetValue(type, out typeTest))
{
typeTest = CreateTest(type.Name, type);
assemblyTest.AddChild(typeTest);
tests.Add(type, typeTest);
}
}
}
}
progressMonitor.Worked(1);
}
TestModelSerializer.PublishTestModel(testModel, messageSink);
return(testModel);
}
protected override void ExploreImpl(IReflectionPolicy reflectionPolicy, ICodeElementInfo codeElement)
{
IAssemblyInfo assembly = ReflectionUtils.GetAssembly(codeElement);
if (assembly == null)
{
return;
}
try
{
NUnitTestExplorerEngine engine;
if (!assemblyTestExplorerEngines.TryGetValue(assembly, out engine))
{
Assembly loadedAssembly = assembly.Resolve(false);
if (Reflector.IsUnresolved(loadedAssembly))
{
engine = new NUnitReflectiveTestExplorerEngine(TestModel, assembly);
}
else
{
engine = new NUnitNativeTestExplorerEngine(TestModel, loadedAssembly);
}
assemblyTestExplorerEngines.Add(assembly, engine);
bool skipChildren = !(codeElement is IAssemblyInfo);
engine.ExploreAssembly(skipChildren);
}
ITypeInfo type = ReflectionUtils.GetType(codeElement);
if (type != null)
{
engine.ExploreType(type);
}
}
catch (Exception ex)
{
TestModel.AddAnnotation(new Annotation(AnnotationType.Error, assembly,
"An exception was thrown while exploring an NUnit test assembly.", ex));
}
}
private Test GetAssemblyTest(IAssemblyInfo assembly, Test parentTest, Version frameworkVersion)
{
Test assemblyTest;
if (assemblyTests.TryGetValue(assembly, out assemblyTest))
{
return(assemblyTest);
}
try
{
Assembly loadedAssembly = assembly.Resolve(false);
if (Reflector.IsUnresolved(loadedAssembly))
{
assemblyTest = BuildAssemblyTest_Reflective(assembly);
}
else
{
assemblyTest = BuildAssemblyTest_Native(assembly, loadedAssembly.Location);
}
string frameworkName = String.Format(Resources.CSUnitTestExplorer_FrameworkNameWithVersionFormat, frameworkVersion);
assemblyTest.Metadata.SetValue(MetadataKeys.Framework, frameworkName);
assemblyTest.Metadata.SetValue(MetadataKeys.File, assembly.Path);
assemblyTest.Kind = AssemblyKind;
}
catch (Exception ex)
{
TestModel.AddAnnotation(new Annotation(AnnotationType.Error, assembly,
"An exception was thrown while exploring a csUnit test assembly.", ex));
return(null);
}
if (assemblyTest != null)
{
parentTest.AddChild(assemblyTest);
assemblyTests.Add(assembly, assemblyTest);
}
return(assemblyTest);
}
private void BuildNUnitFixturesFromType(ITypeInfo type)
{
try
{
// Note: This code takes advantage of the fact that ITypeInfo.Resolve will
// return an UnresolvedType object which adapts ITypeInfo to Type in a
// way that enables the native NUnit builders to perform the needed
// reflection in most cases.
Type resolvedType = type.Resolve(false);
if (NUnit.Core.TestFixtureBuilder.CanBuildFrom(resolvedType))
{
var nunitFixture = (NUnit.Core.TestSuite)NUnit.Core.TestFixtureBuilder.BuildFrom(resolvedType);
nunitFixtures.Add(nunitFixture);
}
}
catch (Exception ex)
{
testModel.AddAnnotation(new Annotation(AnnotationType.Error, type,
"An exception was thrown while exploring an NUnit test type. This probably indicates that the type uses certain NUnit features that are not supported by the reflection-only test explorer engine.", ex));
}
}
private MSTest CreateTypeTest(ITypeInfo typeInfo)
{
MSTest typeTest = new MSTest(typeInfo.Name, typeInfo);
typeTest.Kind = TestKinds.Fixture;
foreach (IMethodInfo method in typeInfo.GetMethods(BindingFlags.Public | BindingFlags.Instance))
{
IEnumerable <IAttributeInfo> methodAttributes = method.GetAttributeInfos(null, true);
foreach (IAttributeInfo methodAttribute in methodAttributes)
{
if (methodAttribute.Type.FullName.CompareTo(MSTestAttributes.TestMethodAttribute) == 0)
{
try
{
MSTest testMethod = CreateMethodTest(typeInfo, method);
typeTest.AddChild(testMethod);
}
catch (Exception ex)
{
TestModel.AddAnnotation(new Annotation(AnnotationType.Error, method, "An exception was thrown while exploring an MSTest test method.", ex));
}
break;
}
}
}
PopulateTestClassMetadata(typeInfo, typeTest);
// Add XML documentation.
string xmlDocumentation = typeInfo.GetXmlDocumentation();
if (xmlDocumentation != null)
{
typeTest.Metadata.SetValue(MetadataKeys.XmlDocumentation, xmlDocumentation);
}
return(typeTest);
}
private void GetInputOutputDirectories(IAssemblyInfo assembly)
{
var config = new SpecificationConfig().Load(assembly.Resolve(false));
var baseInputDirectoryInfo = new DirectoryInfo(config.BaseInputDirectory);
if (baseInputDirectoryInfo.Exists)
{
}
else
{
TestModel.AddAnnotation(new Annotation(AnnotationType.Error, assembly, String.Format("The Base Input Directory {0} does not exist, reverting to default", config.BaseInputDirectory)));
}
var baseOutputDirectoryInfo = new DirectoryInfo(config.BaseOutputDirectory);
this._baseOutputDirectory = baseOutputDirectoryInfo;
if (!_baseOutputDirectory.Exists)
{
Directory.CreateDirectory(_baseOutputDirectory.FullName);
}
}
private Test BuildAssemblyTest_Native(IAssemblyInfo assembly, string location)
{
if (String.IsNullOrEmpty(location))
{
throw new ArgumentNullException("location");
}
// If csUnit.Core is not in the GAC then it must be in the assembly path due to a
// bug in csUnit setting up the AppDomain. It sets the AppDomain's base directory
// to the assembly directory and sets its PrivateBinPath to the csUnit directory
// which is incorrect (PrivateBinPath only specifies directories relative to the app base)
// so it does actually not ensure that csUnit.Core can be loaded as desired.
Assembly csUnitCoreAssembly = typeof(csUnit.Core.Loader).Assembly;
if (!csUnitCoreAssembly.GlobalAssemblyCache)
{
string csUnitAppBase = Path.GetDirectoryName(location);
string csUnitCoreAssemblyPathExpected = Path.Combine(csUnitAppBase, "csUnit.Core.dll");
if (!File.Exists(csUnitCoreAssemblyPathExpected))
{
return(CreateAssemblyTest(assembly, location, delegate(Test assemblyTest)
{
TestModel.AddAnnotation(new Annotation(AnnotationType.Error, null,
string.Format("Cannot load csUnit tests from '{0}'. "
+ "'csUnit.Core.dll' and related DLLs must either be copied to the same directory as the test assembly or must be installed in the GAC.",
location)));
}));
}
}
// Load the assembly using the native CSUnit loader.
using (Loader loader = new Loader(location))
{
// Construct the test tree
return(CreateAssemblyTest(assembly, location, delegate(Test assemblyTest)
{
TestFixtureInfoCollection collection = loader.TestFixtureInfos;
if (collection == null)
{
return;
}
foreach (ITestFixtureInfo fixtureInfo in collection)
{
try
{
ITypeInfo fixtureType = assembly.GetType(fixtureInfo.FullName);
assemblyTest.AddChild(CreateFixtureFromType(fixtureType, delegate(Test fixtureTest)
{
if (fixtureInfo.TestMethods == null)
{
return;
}
foreach (ITestMethodInfo testMethodInfo in fixtureInfo.TestMethods)
{
try
{
IMethodInfo methodType = fixtureType.GetMethod(testMethodInfo.Name,
BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
fixtureTest.AddChild(CreateTestFromMethod(methodType, null));
}
catch (Exception ex)
{
TestModel.AddAnnotation(new Annotation(AnnotationType.Error, fixtureType,
"An exception was thrown while exploring a csUnit test case.", ex));
}
}
}));
}
catch (Exception ex)
{
TestModel.AddAnnotation(new Annotation(AnnotationType.Error, assembly,
"An exception was thrown while exploring a csUnit test fixture.", ex));
}
}
}));
}
}
